Java面向对象思想编程，万物皆对象

一：面向对象

举个栗子：
我想吃饭了，我不想自己做饭，那我就找个对象让她给我做饭吃，
做饭是个方法，我不需要考虑这个饭怎么做饭，我只需要考虑告诉对象我想吃什么就行了，只需要等着吃饭，这就是面向对象思想，哈哈哈哈哈

什么是类？

类：是一组相同属性和行为的对象的集合。

什么是对象？

对象：将类实例化的一个具体体现，对象能将属性和行为具体体现出来。

什么是属性？

属性：类的一些特点/特征

什么是方法（行为）？

行为：就是方法，对象能做的动作。

总结： 以上四个是什么关系？

1.类中有属性和方法。

2.对象由类创建出来，对象内部有它自己具体的属性和方法。

3.对象可以将属性和行为表现出来。

二：面向对象编程（oop）

/**
 * @ClassName Car
 * @Description TODO
 * @Author 张留辉
 * @Date 2023/2/10 11:48
 * @Version 1.0
 * 
 * 类就相当于模板
 * 
 * 对象就是根据摸板创建出的实例
 */
public class Car {
    // 成员属性
    String brand; // 品牌
    double price; // 价钱
    String color; // 颜色
    String num;   // 车牌号       
    // 成员方法
    void run(){
        System.out.println("跑！！！");
    }
    void didi(){
        System.out.println("滴滴！！！");
    }
    void takePeople(){
        System.out.println("载人！！！");
    }
    public static void main(String[] args) {
    }
}

三：创建对象

又叫实例化对象

 public static void main(String[] args) {
        // 对象的创建
        // 类名 对像名 = new 类名();
        Phone phone = new Phone();
    }

四：使用对象

通过对象调用方法中的属性，对属性赋值和调用

public static void main(String[] args) {
        // 对象的创建
        // 类名 对像名 = new 类名();
        Phone phone = new Phone();
        /*
         使用属性，即使用属性和使用方法
         1.设置变量值
             对象名.属性 = 值;
         2.获取变量值
             数据类型 变量名 = 对象名.属性;
         3. 刚创建的属性默认值为他的数据类型的默认值
         */
         // 方法里的变量名     方法里面的属性
        double price = phone.price;
        System.out.println("手机的价格"+price);
        String brand = phone.brand;
        System.out.println("手机的平牌"+brand);
        String color = phone.color;
        System.out.println("手机的颜色"+color);
        int num = phone.memory;
        System.out.println("手机的内存"+num+"G");
        System.out.println("------------------------------");
        phone.brand = "HUAWEI";
        phone.price = 2999.0;
        phone.color = "黑曜石";
        phone.memory = 128;
        double price1 = phone.price;
        System.out.println("手机的价格"+price1);
        String brand1 = phone.brand;
        System.out.println("手机的平牌"+brand1);
        String color1 = phone.color;
        System.out.println("手机的颜色"+color1);
        int num1 = phone.memory;
        System.out.println("手机的内存"+num1+"G");
    }

五：内存图

以创建对象的过程

凡是new都会在内存开辟空间，创建对象，会有地址值。在这同时对象内部的属性和方法会有初始值。 完成对象创建赋值给对象名地址。

后续通过对象.属性找到堆中的对象的属性给其赋值

后续通过对象方法找到堆中对象的方法让其进栈执行。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XAB8c7rU-1676436778223)(D:\前锋学习笔记\笔记\image-20230210160616484.png)]

---

一个类创建多个对象

 /**
         * 一个类中可以有多个对象
         * 每个对象内部都存储着自己的属性和方法
         * 对象之间互不影响
         */
        Car car = new Car();
        car.brand = "玛莎";
        System.out.println(car.brand);

        Car car1 = new Car();
        car1.brand = "劳斯莱斯";
        System.out.println(car1.brand);

        Car car2 = new Car();
        car2.brand="宾利";
        System.out.println(car2.brand);

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZZFnLQxc-1676436778223)(D:\前锋学习笔记\笔记\image-20230210162026404.png)]

多个引用指向一个对象。

 Car car1 = new Car();
 Car car2 = car1;
 car1.num = "888888";
 System.out.println(car1.num);
 System.out.println(car2.num);

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QDr5L0Ow-1676436778223)(D:\前锋学习笔记\笔记\image-20230210163850505.png)]

成员变量和局部变量

局部变量是方法中的变量在整个方法内有效

成员变量是整个类中有效

	局部变量	成员变量：（对象属性，属于对象）
位置	方法内	类体
作用域	方法内	整个类中
初始值	使用前需要必须赋值	默认值，随创建对象的时候付默认值
内存位置	栈的栈针中	在内存的堆中
生命周期	方法进栈初始化，弹栈结束。	对象创建诞生，失去引用后会被GC回收

this关键字

this就是当前类的对象，在方法中就是谁调用这个方法的对象，this就是这个对象。

因为this代表是对象，所以this可以调用自己的属性和方法,如果使用成员变量，就使用this来调用，因为this代表对象，所以可以调用属性。

成员变量和局部变量可以重名，方法内部默认的使用的是自己得到局部变量-----> 就近原则,如果方法没有局部变量，会使用对应的成员变量

public class Cat {
        String name = "小咪咪";
        int age;
        void eat() {
            String name = "大咪咪";
            System.out.println("我叫"+name);
        }
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.eat();
    }
}

假如：目前就局部变量和成员变量重名，且不想使用自己的变量时，怎么解决？使用this

public class demo18 {
        String name = "小咪咪";
        int age;
        void eat() {
            String name = "大咪咪";
            System.out.println("我叫"+this.name);
        }
    public static void main(String[] args) {

        demo18 demo18 = new demo18();
        demo18.eat();
    }
}

因为this就是当前对象，使用this.属性 相当于对象.属性。

this的使用场景：

​ 特别强调使用成员变量时，就使用this调用。

​ 或者当成员变量和局部变量重名时，可以使用this。

this是当前方法也可以调用方法，在主方法中是不能调用的，this是在自己类中调用的。

构造方法（constructor）

构造方法：构造器

特点：

​ 1.是一个方法。目的是构造对象，用来创建对象

​ 2.没有返回值，也不能写void

​ 3.方法名必须是类名

必须通过New的方法来调用

// 类名 对象名 =  new 构造方法();
Cat cat = new Cat();

具体的作用（构造方法一旦执行）：

1.在堆中开辟空间，分配地址值。

2.属性和方法被初始化。

3。对象创建成功。然后将地址值赋给变量名（对象名。）

无参构造

每个类都默认有一个隐藏的无参构造。

因为每个类都要可以默认创建对象，构造方法是为了创建对象而的存在。

构造方法的特点：

​ 1.构造方法首字母大写，且是类名（构造方法是类名，所以首字母大写）。

​ 2.构造方法在类中默认隐式提供（即默认就任务每个都可以创建对象）

3.构造方法没有返回值，也不能写void方法名一定是当前类名。

有参构造

有参构造，就是有参数的构造方法，使用有参构造 ，创建出的对象，对象的属性都是指定值，在创建对象时，调用有参构造方法，方法内部有对属性赋值的过程，所以有参构造创建出对象的属性是指定值。

总结有参构造和无参构造的区别

1.相同点：都能创建出对象。

2.不同点：无参构造创建出的对象属性值都是默认值；有参构造创建出的对象属性值是指定值。

即两者都是创建对象，只是不同得效果，看情况选着使用。

构造方法使用的注意

1.类中默认隐式存在一个无参构造方法

2.也可以显示的写出构造方法，有参和无参的只要有个一显示隐式就不再提供。

3.类中是可以同时存在

4.当类中提供了任何一种构造，隐式的无参不再提供。

子类构造方法中会默认使用super()调用父类的无参构造

方法的重载（overload）

重载：指方法的重载

1.方法是在同一的类中，

2.方法名相同，参数列表不同

3.好处:方便，根据传入的参数个数，顺序，类型，决定哪个方法。

封装

类的封装：将代码封装在一个类中，隐藏一些代码实现的逻辑对外提供一个公共的访问方式。

隐藏一些内容，对外提供一个方法来操作其中的内容。

类的封装的实现步骤：

1.属性私有

3.提供对应的set，get方法。

重写（Override）

重写就是发生继承中，子类重写父类的方法。

为什么要重写？

​ 因为父类的方法不够具体，所以子类需要重写父类方法以满足自己的情况

this 和 super

任何类的每一个构造方法都隐式存在一个super（）来调用父类的无参构造。

	this	super
意义	代表当前对象	代表的是当前对象的父类对象
属性调用	this.属性；调用自己的属性	super.属性；调用父类属性
方法调用	this.方法();调用自己的方法	super.方法；调用父类的方法，
构造方法	this()；调用自己的无参构造	super()；调用父类无参构造
	this(参数）;调用自己有参构造	super(参数)；调用父类有参构造。

多态

同一个方法在运行时有不同的效果。

实现多态的前提：

​ 1.要有子父类的关系

​ 2.要重写方法

​ 3.父类引用指向子类对象

总结：

what 是什么 when什么时候 where 哪 how 怎么