Java学习——面向对象

面向对象

---

类

• 属性
• 方法

面向对象的本质：以类的方式组织代码，以对象的组织（封装）数据。

---

创建与初始化对象

• 使用new关键字创建，除了会分配内存空间以外，还会给 创建好的对象 进行默认的初始化，以及对类中构造器的调用
• 类中的构造器也成为构造方法，是在进行创建对象的时候必须要调用的。而且构造器有以下两个特点：
  1. 必须和类的名字相同
  2. 必须没有返回类型，也不能写void
• 构造器必须要掌握

---

构造器

⌨使用快捷键 alt+insert可以生成

• 和类名相同
• 一个类即使什么都不写，它也会存在一个方法（无参构造）
• 用来初始化值

public class Person{
	String name;
	// 构造器
	// 主要是用作实例化初始值
	public Person(){
		 this.name = "小明";
	}
}

• 使用new关键字，本质是在调用构造器
• 可以手动创建有参构造器（有参构造） 一旦定义了有参构造，无参就必须显示定义

public class Person{
	String name;
	// 构造器
	// 主要是用作实例化初始值
	public Person(){}  // 无参构造
	public Person(String name){
		this.name = name;
	}
}

通过讲解堆栈，来看对象如何创建的内部过程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VeS4KoK4-1609727532920)(%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1%20725ce62f8fb14e7caec1c4936faf638f/Untitled.png)]

引用类型

基本类型（8）

对象是通过引用来操作的：栈——>堆

属性

字段Field 成员变量

默认初始化： 数字：0 0.0

char：u0000

bolean：false

引用：null

三大特性：

1. 封装：

• 程序设计追求“高内聚，低耦合”
• 封装（数据的隐藏）
• 属性私有，get/set 👇

⌨使用快捷键 alt+insert可以生成

优点：1. 提高程序的安全性，保护数据。2.隐藏代码的实现细节。3.统一接口。4.提高系统可维护性

2. 继承：

• 继承的本质是对某一批类的抽象
• extends的意思是——扩展。子类是父类的扩展。

Java中只有单继承，没有多继承！

• 在Java中所有的类都默认直接/间接，继承Object类

public class Person /* extends Object */{

}
// 一般可以省略 extends Object
// 可以使用 Ctrl + H 将继承树列举出来

• 在子类的构造其中，隐式地调用了父类的构造器

显示地调用父类的构造器，必须要在子类构造器的第一行
父类没有无参构造器，子类也没有无参构造器

public Student() {
        //    隐藏的调用了父类的无参构造   注意：调用父类的构造器，必须要在子类构造器的第一行
        super();
        System.out.println("Student无参构造执行了");
    }

#注意点

Super注意点：
1. super调用父类的构造方法，必须在构造方法第一个；
2. super必须只能出现在子类的方法或者构造方法中；
3. super 和 this不能同时调用构造方法；
this：
- 代表对象不同
1. 本身调用者这个对象
2. super：代表父类对象的应用
- 前提

      1. this  没有继承也可以使用

      2. super 只能在继承的条件下使用    

- 构造方法

      1. this()调用的是本类的构造

      2. super()调用的是父类的构造

• 方法重写

  必须要有继承的关系，才可以重写父类的方法，而不是属性。

  // 方法的调用，只和左边（定义的数据 类型）有关
  A a = new A();
  a.test(); // A
  
  // 父类的引用指向了子类
  B b = new A();
  b.test(); // B  静态方法    结果为A  非静态方法
  

1. 静态方法会发生上面的情况，但是非静态方法b.test()的调用，依旧会是A。（因为静态方法在类加载的时候就会出现）
2. 重写的方法必须是public
3. 方法名必须相同
4. 参数列表必须相同
5. 修饰符：范围可以扩大，但是不能被缩小：public > protected > default > private
6. 抛出的异常：范围可以被缩小，但是不能被扩大：ClassNotFoundException —→Exception（大）

• 为什么需要重写？
  • 父类的功能，子类不一定需要，或者不一定满足！Alt + Insert ——> override

3. 多态：

动态编译：类型：可扩展性

即同一方法对根据发送对象的不同而采用多种不同的行为方式。

一个对象的实际类型是确定的，但可以指向对象的引用的类型有许多

• 多态存在的条件
  • 有继承关系
  • 子类重写父类方法
  • 父类引用指向子类对象

🐖：多态是方法的多态，属性没有多态性。

//       一个对象的实际类型是确定的
//        new Student()
//        new Person()

//        可以指向引用的类型就不确定了，父类的引用指向子类
//        父类的引用指向子类，student能调用的方法，都是自己的或者是继承父类的
        Student s1 = new Student();
//        Person父类型，可以指向子类，但是不能调用子类独有的方法
        Person s2 = new Student();
        Object s3 = new Student();

//        子类重写了父类的方法，所以会知行子类的方法
        s2.run();
        s1.run();

//        对象能执行哪些方法，是看左边的类型，和右边的关系不大
//        s2.eat();
//        高类型转低类型可以强制转换
        ((Student)s2).eat();
    }

/*
    多态的注意事项：
    1. 多态是方法的多态，属性没有多态
    2. 父类和子类，有联系    类型转化异常！ ClassCastException！
    3. 存在的条件：继承关系，方法需要重写，父类的引用指向子类对象！ Father f1 = new Son();
        一下三种不可以重写：
            - static 方法，属于类，他不属于实例
            - final 常量：
            - private 方法：

    注意：多态是方法的多态，属性没有多态性
    instanceof （类型转换）
 */

#### instanceof

— instanceof — （类型转换）引用类型，判断一个对象是什么类型。

// Object > Person > Teacher 如果不是最近父类则为false
System.out.println(Object instanceof Person);//True
System.out.println(Object instanceof Teacher);//False

1. 父类引用指向子类的对象
2. 把子类转换为父类，向上转型：可能丢失自己本来的一些方法
3. 把父类转换为子类，向下转型：强制转换
4. 方便方法的调用，减少代码的重复，简洁

---

static关键字详解

    private static int age; //静态变量 多线程
    private double score; // 非静态变量
		//  静态方法与类一同加载，所以静态方法可以调用静态方法，无法调用动态方法；

		Student s1 = new Student();
    System.out.println(Student.age);
    System.out.println(s1.age);
    System.out.println(s1.score);

匿名代码块与静态代码块

第二个执行的
{
	// 代码块（匿名代码块）
	// 第二个执行
}

--------

最早执行的
static {
	// 静态代码块
	// 最早执行
} // 类一加载就开始执行，而且 ***只执行一次***

都是在构造方法之前执行

public XX(){
	// 最后执行
}

静态导入包

import static java.lang.Math.random;
public class Test{
	public static void main(String[] args){
		System.out.println(random());
	}
}

final修饰的类

final修饰的类无法被继承了。——>断子绝孙

---

抽象类（abstract修饰）

abstract，抽象方法，只有方法的名字，没有方法的实现

抽象类的所有方法，继承了它的子类，都必须要实现他的方法。除非子类也是abstract修饰的类

类 extends：单继承~ （接口interface可以多继承）

⚠Warning

1. 不能new这个抽象类，只能靠子类去实现它：约束；
2. 存在抽象方法时，类必须使用abstract修饰；但是，抽象类中可以写普通方法；
3. 抽象的抽象：约束~

💬存在的意义

1. 抽象出来，提高开发效率；

---

接口

——> 声明接口的关键字是interface
接口都需要有实现类关键字是implements

普通类：只有具体实现；
抽象类：具体实现和规范（抽象方法）都有；
接口：只有规范！自己无法写方法；专业的约束！约束和实现分离：面向接口编程

• 接口就是规范，定义的是一组规则。接口的本质是契约

public interface UserService {
//    接口中定义的属性是常量，public static final
		int AGE = 99;
//    接口中的所有定义的方法都是抽象的public abstract
    void run(String name);
}

🗨️作用

1. 约束；
2. 定义一些方法，让不同的人实现；
3. public abstract；
4. public static final；
5. 接口不能被实例化，接口中没有构造方法；
6. 可以实现多个接口；
7. 必须要重写接口中的方法；

---