类、方法、初始化、对象的销毁、this和super
五、面向对象 基础

1 - 面向过程 与 面向对象的区别

面向过程的语言：c

面向对象的语言：c++,java,c#

  • 面向对象语言的特征
    • 面向对象是一种常见的思想，比较符合人们的思考习惯
    • 可以将复杂的逻辑简单化，增强带按摩的复用性
    • 面向对象具有抽象，封装，继承，多态等特性

2 - 类

2 - 1 类的创建

构造方法：

class Cat(){
    // 类的属性
    private String name;
    private Integer age;

    // 无参构造方法
    public Cat() {
    }
    
    // 包含一个属性的构造方法
    public Cat(String name) {
        this.name = name;
    }

    public Cat(Integer age) {
        this.age = age;
    }

    // 包含所有属性的构造方法
    public Cat(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

3 - 方法

3 - 1 对象 及 对象引用

  • 创建对象的引用
Cat cat；

  • 创建对象

    Cat cat = new Cat();

    一个引用可以指向多个对象，而一个对象可以被多个引用所指；

    // 一个引用可以指向多个对象
Cat cat ;
Cat cat1;

// 一个对象可以被多个引用所指
cat = new Cat("小猫",5);
cat = new Cat("大猫",6);

3 - 2 构造方法

用于初始化对象，且只在对象创建初期调用一次

不手动创建构造方法时，JVM会为你默认添加一个无参构造器，但如果手动创建了构造方法，则JVM不会在为你创建默认的构造器，需要自己添加

没有参数类型和返回值，且名称要与类名保持一致，且构造方法可以有多个

	// 无参构造方法（默认的构造方法）
    public Cat() {
    }
    
    // 包含一个属性的构造方法
    public Cat(String name) {
        this.name = name;
    }

    public Cat(Integer age) {
        this.age = age;
    }

    // 包含所有属性的构造方法
    public Cat(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

3 - 3 方法重载

每个重载方法都有一个独一无二的参数列表（即数量、类型、顺序不同）

  • 重载的条件
    • 在同一个类中
    • 重载方法名必须相同
    • 重载方法的参数列表必须不同
    • 仅仅返回值不同不能构成重载
    • 重载方法返回值可以相同可以不同
    • 重载是发生在编译时，因为编译器可以通过参数的类型（参数列表）来选择使用哪个方法

3 - 4 方法的重写

方法重写是针对子类和父类之间的

特征：

​ 1、重写的方法与父类保持一致，包括返回值类型，方法名，参数列表也必须一致

​ 2、子类中重写方法的访问权限不能低于父类中的访问权限

​ 3、重写方法可以用注解@Override来标注

// 父类
class Animal{
    public void Eat(String name){
        System.out.println(name + "在吃饭！");
    }
}

// 子类
class Cat extends Animal{

    @Override
    public void Eat(String name){ // 子类重写父类的Eat()方法
        System.out.println(name + "在吃饭！但它不想吃！！！" );
    }

}

4 - 初始化

  • 初始化顺序

    静态属性 > 静态代码块 > 普通属性 > 普通代码块 > 构造函数

    静态属性与静态代码块在程序启动后均只执行一次

    1. 静态属性：static修饰的属性
    2. 静态方法块：static{}包起来的代码块
    3. 普通属性：非static修饰的属性
    4. 构造代码块：用{}包裹起来的代码
    5. 构造函数：类名相同的方法
    6. 方法：普通的方法
    public class Main {
    public static void main(String[] args) {
        Text text  = new Text();
    }
}
class Text{
    // 静态属性
    public static String staticFiles = getStaticFiles();

    // 普通属性
    public String files = getFiles();

    // 静态代码块
    static {
        System.out.println("静态代码块！");
    }
    
    // 构造代码块
    {
        System.out.println("普通方法块");
    }

    // 构造方法
    public Text() {
        System.out.println("构造方法初始化");
    }

    public static String getStaticFiles(){
        System.out.println("静态属性！");
        return "---staticFiles---";
    }

    private String getFiles() {
        System.out.println("普通属性！");
        return "---files---";
    }
}

5 - 对象的销毁

  • java虽然是基于C++的一门高级语言，但 java 与 c/c++ 的不同的重要特征就是不需要手动的管理对象的销毁工作，而是java虚拟机进行管理和销毁的。

6 - this 和 super

this和super均是java中的关键字

this表示当前对象，有3个作用：

​ 调用方法、调用属性、调用对象本身

// 指向当前对象
public class Apple {
    int num =0;

    public Apple eatApple(){
        num++;
        return this; // 返回当前对象
    }

    public static void main(String[] args) {
        Apple apple = new Apple();
        // 由于this的原因,eatApple()可以重复调用，哪个对象调用eatApple()方法，都会返回对象本身
        apple.eatApple().eatApple(); 
    }
}

// 修饰属性，通常用于构造方法
public class Apple {
    int num =0;

    public Apple(int num){
        this.num = num;

    }

    public static void main(String[] args) {
        Apple apple = new Apple(20);
        System.out.println(apple.num);// 此时num=20

    }
}

this()方法必须放在构造方法第一句，否则编译不通过

// 与构造方法一起使用，充当全局关键字
public class Fruit {
    int num ;
    String fruit;


    public Fruit(int num){
        this(num,"苹果");
    }


    public Fruit(int num,String fruit){
        this.num = num;
        this.fruit = fruit;
    }

    public static void main(String[] args) {
        Fruit apple = new Fruit(20);
        
        System.out.println(apple.num+ "个" +apple.fruit);

    }
}

super与this功能类似，不同的是super操作的对象是父类