东瓶西镜

Welcome to my blog

0%

面向对象

发表于 更新于 分类于
本文字数： 2.9k 阅读时长 ≈ 5 分钟
设计对象并使用&封装&内存图

面向对象

​ 面向对象介绍:

​ 面向:拿，找。

​ 对象:能干活的东西。

​ 面向对象编程:拿东西过来做对应的事情。

  1. 设计对象并使用

    1. 类和对象

      类(设计图):是对象共同特征的描述(类名首字母建议大写，需要见名知意，驼峰命名)；

      对象:是真实存在的具体东西(在Java中，必须先设计类，才能获得对象)

      如何得到对象: 

      1
      2
      3
      4
      5
      public class 类名{
          1.成员变量(代表属性的，一般是名词)//完整定义格式:修饰符 数据类型 变量名称= 初始化值;一般无需指定初始化值(创建对象后									再赋值),存在默认值，修饰符一般不写
          2.成员方法(代表行为的，一般是动词)
      }
      类名 对象名 = new 类名( );

      如何使用对象:

      ​ 访问属性:对象名.成员变量

      ​ 访问行为:对象名.方法名(…)

      类的注意事项:

  开发中的设计

   1. 用来描述一类事物的类，专业就叫:**javabean类**。在javabean类中，是不写main方法的

   2. 在以前，编写main方法的类，叫做**测试类**。可以在测试类中创建javabean类的对象并进行赋值调用。

   3. 一个**Java文件**中可以定义多个class类，且只能一个类是public修饰，而且public修饰的类名必须成为代码文件名，实际开发中建议还是一个文件定义一个class类

      
1
2
3
4
5
6
7
8
9
10
public class A {
    public static void main(String[] args) {
        System.out.println("hello");
    }
}
----------------------------
class B {
}
class C {
}

  1. 封装

    告诉我们，如何正确设计对象的属性和方法。

    原则:对象代表什么，就得封装对应的数据，并提供数据对应的行为。（　张三　杀　李四（生死状态））

    private关键字:是一个权限修饰符,可以修饰成员(成员变量和成员方法). 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    //1.数据安全问题(p.age=-99)
     被private修饰的成员只能在本类中才能访问**(*解决了数据安全问题*).
         private int age;
    //2.实现正确的数据可以赋值,错误的无法赋值-通过get set方法赋值,过滤通道
    //set(赋值)
    public void setAge(int a){//在所有的类中都可以使用它修饰的成员
        if(a>=18&&a<50){
            age=a;
        }else{
            System.out.println("非法数据");
        }
    }
    //get(获取)
    public int getAge(){
        return age;
    }
    //被其他的类调用和访问
    //在测试类中调用赋值
    GirlFriend gf1=new GirlFriend();
    gf1.setName("AA");
    gf1.setAge(19);
    //获取
    String name = gf1.getName();
    int age=gf1.getAge();

    this关键字:

    成员变量(方法外,类里面)和局部变量(方法里).就近原则,想用成员变量需加this.

    this关键字的作用可以区别成员变量和局部变量.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    public class GirlFriend{
    private int age;
    //set(赋值)
    public void setAge(int age){//在所有的类中都可以使用它修饰的成员
        if(a>=18&&a<50){
            this.age=age;
        }else{
            System.out.println("非法数据");
        }
    }
    //get(获取)
    public int getAge(){
        return age;
    }   
    }

  2. 构造方法:

    格式:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    public class Student{
        修饰符 类名(参数) {
            方法体;
        }
        public Student(){
            //空参构造方法
        }
        public Student(String name,int age){ //创建对象调用实参构造:Student s = new Student("AA",19);
            //全参构造方法
        }
    }
    //★★★★★★★★
    //全参构造,在方法里面就可以给所有的成员变量赋值,不用再用set方法进行赋值了,简化代码.
    //空参的构造方法,利用空参构造创建对象,成员变量默认初始化值.,
    //如果我们自己没写任何构造方法,那么虚拟机会给我们加一个空参构造方法;如果已经定义了带参构造方法,系统将不会提供默认的无参构造方法.
    //构造方法的重载,带参构造方法和无参构造方法,两者方法名相同,但是参数不同,这叫做构造方法的重载.
    //执行时机:构造方法不能手动调用,在创建对象的时候由虚拟机调用,每创建一次对象就调用一次构造方法.
    //★★★★★★★★

    特点:方法名和类名相同,大小写也要一致;

    ​ 没有返回值类型,连void都没有;

    ​ 没有具体的返回值(不能由return带回结果数据);

    作用:在创建对象的时候由虚拟机自动调用构造方法给成员变量进行初始化(赋值)的.

    建议:实际开发中,空参构造和有参构造都会写上,因为有时不完全知道属性值

  3. 标准JavaBean

    1. 类名需要见名知意,驼峰命名
    2. 成员变量使用private修饰
    3. 提供至少两个构造方法(无参构造方法&全参构造方法)
    4. 成员方法:提供每一个私有化的成员变量对应的setXxx()/getXxx()方法,如果还有其他行为,也需要写上

  4. 对象内存图

    方法区:字节码文件加载时进入的内存

    栈内存:方法运行时所进入的内存，变量也在这里

    堆内存:new出来的东西会在这块内存中开辟空间并产生地址

    一个对象的内存图:

    Student s = new Student();

    ​ 1.加载class文件(方法区临时存储main()方法，虚拟机调用main()方法，main()方法加载进栈)

    ​ 2.申明局部变量

    ​ 3.在堆内存中开辟一个空间

    ​ 4.默认初始化

    ​ 5.显示初始化

    ​ 6.构造方法的初始化

    ​ 7.将堆内存中的地址值赋值给左边的局部变量

    多个对象的内存图:

    对个对象时class对象不用重新加载

    两个变量指向同一个对象内存图:

    this的内存原理:

    作用：变量得就近原则，区分局部变量和成员变量。

    本质：所在方法调用者的地址值

    ​

    基本数据类型和引用数据类型的区别:

     基本数据类型：数据值是存储在自己的空间中(栈)，赋值给其他变量，也是赋得真实得值。

    ​ 引用数据类型：数据值 是存储在其他空间中，自己空间中存储得是地址值，赋值给其他变量，赋得是地址值

    局部变量和成员变量的区别:

    ​ 成员变量：类中方法外的变量

    ​ 局部变量：方法中的变量，（栈里面的局部变量没有默认值，是要给个初始化值才能用的）