JavaSE（五）类与对象

类与对象

• 面向对象；

• Java语言是一门面向对象的编程语言；Object Oriented Programming OOP(面向对象编程)

• 编程思想：面向过程 VS 面向对象

• 程序是模拟现实世界，程序是对现实世界的一种抽象；面向对象的编程思想更加符合对现实世界的模拟；

• 理发：1 洗头 2 理发过程 3吹 4 洗 ；找理发店对象 让他给我提供理发的功能（方法）

• 吃早餐；喝胡辣汤 找早餐店对象 让这个对象给我提供服务

• 对象 Java万事万物皆对象；对象是类的实例 实物；一定是先有类 才能有此类的对象

1.1.类

• 类型 数据类型 ；Java的数据类型 一个基本数据类型 一个引用数据类型

• Java允许程序员自定义类型；自定义的都是引用类型；

• 通用的类型 String Scanner

• 类的定义包含 2大成分；有什么特征（属性，成员变量） 干什么功能（方法）

• 类是一组事物 相同特征（有什么）和相同的行为（能干什么）的抽象 ；类是一个模板；

1.类的定义

/**
 * 类的定义  数据类型
 * public：权限修饰符
 * ****权限修饰符（4个 public protected 缺省  private） 修饰类，成员变量，方法
 * ****一般使用 public 和 缺省（不写）修饰类 class
 * ****一个源文件中 public修饰的类 只能有一个，而且这个类名必须和源文件名保持一致
 * class:关键字 修饰类的定义
 * Student：类名 标识符；类名的首字母大写,方法名和成员变量名 局部变量名首字母都是小写
 * {类体}
 */
public class Student {
    //有什么特征 属性 成员变量
    //成员变量的定义语法：权限修饰符（4个） 任意数据类型 属性名（或者成员变量名）;
    public int id;
    public String name;
    public int age;
    public char gender;
   
​
    //能干什么 功能 方法定义
    public void eat() {
        int num = 10;
        System.out.println("");
    }
​
    public void study() {
        System.out.println("在学习");
    }       
}
​
//一个源文件中可以定义多个类型的，但是public类只有有一个
//实际开发过程中 一般来说 一个源文件中只定义一个类型
/*
class Teacher {
​
}
​
class Computer {
}
*/

1.2.对象

• 必须要先定义一个类型，才能有此类型的对象出现

• 对象是实例

1，对象的创建和对象的使用

 /**
     * 对象的创建和对象的使用
     */
    private static void method1() {
        // Student类型
        int num1 = 10;
        //引用类型的值 都称之为对象;对象都是new出来的；
        //对象其实就是这种类型的实例 实实在在的例子 是实物
        Scanner sc = new Scanner(System.in);
        //创建Student类型的对象,对象都是new出来的；
        Student stu1 = new Student();
        //使用对象  成员变量 方法   .运算符
        //给这个对象的成员变量赋值
        stu1.id = 1001;
        stu1.name = "张飞";
        stu1.age = 26;
        stu1.gender = '男';
        //取这个对象的成员变量的值
        System.out.println(stu1.id);
        System.out.println(stu1.name);
        System.out.println(stu1.age);
        System.out.println(stu1.gender);
        //方法调用 对象名.方法名();
        stu1.eat();
        stu1.study("红楼梦");
        //调用本类体中声明方法
        // study("红楼梦");
    }

2，内存分布

/**
     * 对象的内存分布
     */
    private static void method2() {
        //先有类型定义 才能有此类型对象
        //凡是new出来的都是对象；对象都在堆空间中；只要看到new JVM都会在堆中新开辟的空间
        // 对象的内存空间中存储的是此对象的成员变量的值；成员变量都有默认值零值 成员变量的值每个对象都存储一份 互不影响；
        //stu1变量名 引用类型的变量名，引用类型的变量中存储的另外一块内存的起始地址值
        //stu1: 变量名 引用  对象名
        Student stu1 = new Student();
        stu1.id = 1001;
        stu1.name = "张飞";
        System.out.println(stu1.id);
        System.out.println(stu1.name);
        System.out.println("===========");
        Student stu2 = new Student();
        System.out.println(stu2.id);
        System.out.println(stu2.name);
    }

1.3.方法的重载

• 方法的重载：同一个类体中 方法名相同而形参列表不同

  • 形参个数不同

  • 形参类型不同

  • 形参顺序不同

public class Car {
    //方法重载
    public void run() {
    }
​
    public void run(int wheeNum, String str) {
    }
​
    public void run(String str, int wheelNum) {
​
    }
}

1.4.构造方法

• 构造方法：为了把程序员给成员变量的初始值直接赋给对象 而不是都使用JVM给的零值;

• 构造方法是非常特殊的方法: 没有返回值 且名称必须和类名保持一致

• 构造方法也是方法，也能进行方法的重载：方法名相同 而形参列表不同

• 如果程序员没有显示添加任何构造方法的时候 此时编译器会默认添加一个无参空体构造方法；一旦程序显示添加构造方法，编译器不再默认添加无参构造方法了

• 开发习惯：无参构造方法都要加上

1，构造方法的定义

public class Computer {
    //成员变量是一定会有值的，程序员不给 JVM就要给零值；
    public String brand;
    public double price;
    /* 构造器：构造方法
    构造方法：为了把程序员给成员变量的初始值直接赋给对象 而不是都使用JVM给的零值
     *****构造方法是非常特殊的方法: 没有返回值 且名称必须和类名保持一致
     构造方法也是方法，也能进行方法的重载：方法名相同 而形参列表不同
     如果程序员没有显示添加任何构造方法的时候 此时编译器会默认添加一个无参空体构造方法；
     ***一旦程序显示添加构造方法，编译器不再默认添加无参构造方法了
     开发习惯：无参构造方法都要加上
     */
    public Computer() {
        //无参构造中 JVM给所有的成员变量赋零值
    }
    public Computer(String str){
        brand = str;
    }
    public Computer(String str, double p) {
        brand = str;
        price = p;
    }
    //方法
    public void program() {
    }
}

2，构造方法的使用

public static void main(String[] args) {
        //只要有小括号 都是方法调用;
        //构造方法是在创建对象的时候 被调用的
        Computer com1 = new Computer();
        System.out.println(com1.brand);
        System.out.println(com1.price);
        Computer com2 = new Computer("戴尔");
        System.out.println(com2.brand);
        System.out.println(com2.price);
        Computer com3 = new Computer("戴尔", 88.99);
        System.out.println(com3.brand);
        System.out.println(com3.price);
    }

1.5.局部变量VS成员变量

1. 定义位置不同：局部变量定义在方法体中，成员变量定义在类体中

2. 有关权限修饰符：局部变量不能使用权限修饰符；成员变量前面必须有权限修饰符的

3. 存储位置不同：局部变量的值存储在栈中 ，成员变量的值存储在对象中 而对象在堆中；

4. 使用的不同：变量（变量使用之前必须要有值），局部变量是一定要先赋值才能使用；成员变量有默认值 JVM给的零值 可以直接使用；

5. 当两者重名的时候，优先访问的是局部变量；如果要访问的是成员变量 需要使用关键字this去指代访问的是成员变量；

1.6.this关键字

• this 这个；this只出现在方法体中（普通方法 构造方法）；this指代当前对象

• this表示当前对象；谁在调用我这个方法 当前对象就是谁

• this使用的场景：

  • 当成员变量和局部变量重名了，优先访问的是局部变量；可以使用this区分要访问的成员变量

  • 在构造方法中 去调用另一个构造方法；this() ;

public class Student {
    public int id;
    public String name;
    public int age;
​
    public Student() {
    }
​
    //形参 局部变量
    public Student(int id, String name) {
        this.id = id;
        this.name = name;
    }
​
    public Student(int id, String name, int age) {
        //构造方法的调用 必须出现在首行
        this(id, name);
        this.age = age;
    }
​
    public void read() {
        System.out.println(this.name + "在阅读");
    }
​
    public void study() {
        //String name = "Tom";
        //直接写name 其实本质就是this.name
      /*  Student stu2 = new Student(1003, "刘备");
        stu2.read();*/
        this.read(); // read();
        //System.out.println(name + "在学习");
        System.out.println(this.name + "在学习");
    }
}