2021-04-07

面向对象

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

2.三大特征： 封装、继承、多态。

3.类是抽象的，对象是具体的。

一、创建与初始化对象

1. 关键字 new ： 可以分配空间，还会给创建好的对象进行默认的初始化，以及对类中构造器的调用。

2. 构造器：

   ​ a.必须和类的名字相同。

   ​ b.必须没有返回类型，也不能写void。

public class Student {
    public static void main(String[] args) {

        //类：抽象的
        //类实例化回返回一个自己的对象
        //people就是一个People类的具体实例

        People people = new People();
        people.name="刘朝";
        people.age=10;

        System.out.println(people.age);
        System.out.println(people.name);

    }
}


//people 类
public class People {
    //属性
    String name;
    int age;
    //方法
    public void study(){
        System.out.println(this.name+"在玩耍");
    }
}

二、封装

1.高内聚：类的内部数据操作细节自己完成，不允许外部干涉。

2.低耦合：仅暴露少量的方法给外部使用。

3.数据的隐藏：应禁止直接访问一个对象中数据的实际表示，而应该通过操作接口来访问。

4.属性私有 get / set

public class Student01 {
    
    //student01类的属性
    //私有属性 不可直接访问
    private String name ;
    private int age;

    // get and set 的使用方法
    public String getName(){
        return name;
    }

    public void setName(String name){
        this.name = name;
    }
}
public class School {
    public static void main(String[] args) {
        
        //对Student01类的实例化
        Student01 student = new Student01();
        
        //调用私有姓名（赋值）
        student.setName("刘朝");
        System.out.println(student.getName());
    }
}

三、继承

1.关键字 extends ：子类是父类的扩展

2 java：只有单继承，没有多继承。

3 this和super

​ a. super调用父类的构造方法，必须在构造方法的第一个

​ b. super必须只能出现在子类的方法或构造中。

​ c. super 和this 不能同时调用构造方法。

4 super VS this

​ a.代表的对象不同：

​ this：本身调用者这个对象

​ super： 代表父类对象的应用

​ b.前提

​ this ：没有继承也可以使用

​ super：只能在继承条件下才能使用

​ c. 构造方法

​ this() ; 本类的构造

​ super(); 父类的构造

// 父类
public class Father {
    //定义一个name属性
    public String name = "父亲";
}

// 子类  派生类
// keyword  extends  继承
public class Son extends Father {
	//定义一个name属性
    public String name = "儿子";
	
    public void text(String name){
        // this 指代本类中定义的name
        System.out.println(this.name);
        //super 指代继承的父类中的 name
        System.out.println(super.name);
        // 此 name 为方法中的变量
        System.out.println(name);
    }
}


public class Text {
    public static void main(String[] args) {
        //对son类进行实例化
        Son son = new Son();
        son.text("测试");
    }
}

四、多态

1.多态是方法的多态，属性没有多态。

2.父类和子类 （有联系的类） 类型转换异常！ ClassCastException!

3.存在条件：继承关系，方法需要重写，父类引用指向子类对象 例： Father father = new Son();

4.不可以重写的情况：

​ a. static 方法， 属于类，它不属于实例。

​ b. final 常量

​ c. private 方法

5.类型转换

​ a.高到低直接转换 Father father = new Son(); 父类指向子类

​ b.低到高需要强制类型转换

​ Student student = (Student) father;

​ student. eat();

​ 简洁 ((Student // 需要转换的类型)father ).eat();

public class A//(父类) {
    public void run(){
        System.out.println("run");
    }

}

public class B extends A{

    public void run(){
        System.out.println("B");
    }
    public void eat(){
        System.out.println("eat");
    }
}
public class World {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的
        //new A();
        //new B();

        //可指向的引用类型就不确定了：
        B s1 = new B();
        //父类的引用指向了子类
        A s2 = new B();
        Object s3 = new B();

        // 对象能执行哪些方法主要看对象左边的类型，和右边的关系不大。
        s1.run();
        s2.run();       //子类重写了父类的方法，执行子类的方法

        s1.eat();
        ((B)s2).eat();   //强制类型转换
    }
}

五、抽象类

1. 关键字 abstract

2. 注意事项

   a.不能new 这个抽象类，只能靠子类去实现他； 约束

   b.抽象类可以写普通的方法

   c.抽象方法必须在抽象类中

六、接口

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

//interface 定义接口的关键字  接口都需要有实现类
public interface A {
    //接口中所有定义的方法都是抽象类的  public abstract
    void run();
}

public interface C {
    void add();
}

// 类可以实现接口 implements  接口
//实现了接口的类就要重写该方法
public class B implements A ,C/*利用接口实现多继承*/ {
    public void run(){}
    public void add(){}
}