JavaSE--面向对象的三大特征

一.封装

程序设计要追求**“高内聚，低耦合”**。高内聚：类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。

封装（数据的隐藏）：禁止直接访问一个对象中数据的实际表示，应通过操作接口来访问，称为信息隐藏。

属性私有，get/set

封装的意义：

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

public class Student {
    
    private String name;
    private int age;
    private char sex;

    //get:获得这个数据
    public String getName(){
        return this.name;
    }

    //set：给这个数据设置值

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

不能直接调用对象的私有属性，因此提供一些public的get、set方法可以操作这些私有属性！

Alt + Insert 可以自动生成sette和getter。

二.继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。

extends的意思是“扩展”。子类是父类的扩展。

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

继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。
继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。
子类和父类之间，从意义上应该具有“is a”的关系。

在Java中，所有的类都默认直接或者间接继承Object，Ctrl+H可查看继承关系。

①super和this

public class Person {//父类
    public Person(){
        System.out.println("Person无参执行了");
    }
    protected String name = "Person";
}
public class Student extends Person{//子类
    public Student(){
        //隐藏代码：调用了父类的无参构造
        super();//调用父类的构造器，必须要在子类构造的第一行
        System.out.println("Student无参执行了");
    }
    private String name = "Student";
     public void print(String name){
         System.out.println(name);//s1:形式参数的值
         System.out.println(this.name);//Student：当前类的值
         System.out.println(super.name);//Person：父类的值
     }
}
public abstract class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.print("s1");
    }
}

super注意点：

1. super调用父类的构造方法，必须在构造方法的第一个。
2. super必须只能出现在子类的方法或者构造方法中！
3. super和this不能同时调用构造方法

与this的不同：

1. 代表对象不同：

   this：本身调用的这个对象

   super：代表父类对象的应用

2. 前提：

   this：没有继承也可以使用

   super：只能在继承条件才可以使用

3. 构造方法：

   this()：本类的构造

   super()：父类的构造

②方法的重写

方法的重写需要有继承关系，子类重写父类的方法，和属性无关！

1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符：范围可以扩大但不能缩小： public>protected>default>private
4. 抛出的异常：范围可以被缩小但不能扩大：ClassNotFoundException–>Exception(大)

重写，子类的方法和父类必须一致，方法体不同！

为什么需要重写：父类的功能，子类不一定需要，或者不一定满足！

Alt + Insert :override;

public class B {
    public void test(){
        System.out.println("B=>test");
    }
}

public class A extends B{

    @Override
    public void test() {
        System.out.println("A=>test");
    }
}

public  class Application {

//静态方法和非静态方法区别很大！
    //静态方法：调用只和左边，定义的数据类型有关
    //非静态方法：重写
    public static void main(String[] args) {
        
        A a = new A();
        a.test();//"A=>test

        //父类的引用指向了子类
        B b = new A();//子类重写了父类的方法
        b.test();//"A=>test
    }
}

三.多态

1.多态综述

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

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

注意事项：

1. 多态是方法的多态，属性没有多态。
2. 父类和子类：有联系 类型转换异常！ClassCastException！
3. 存在条件：继承关系，方法需要重写，父类引用指向子类对象！ Father f1 = new Son()；

不能被重写的方法:

1. static方法，属于类，它不属于实例。
2. final常量，存储在常量池中
3. private方法，私有的方法也不可以被重写。

public class Person {
    public void run(){
        System.out.println("run");
    }
}

public class Student extends Person {

    public void run(){
        System.out.println("son.run");
    }

    public void eat(){
        System.out.println("eat");
    }
}

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

        //一个对象的实际类型是确定的
        //可以指向的引用类型就不确定了：父类的引用指向子类

        //Student 能调用的方法都是自己的或者继承父类的
        Student s1 = new Student();
        //Person 父类：可以指向子类，但是不能调用子类的方法
        Person p1 = new Student();
        Object o1 = new Student();

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

2.instanceof

instanceof：判断一个对象是什么类型,语法如下：

System.out.println(X instanceof Y);

是否编译成功：看X的实际类型和Y有没有联系。
输出结果：

1. true：X的引用类型和Y具备父子关系。
2. false：X的引用类型和Y不具备父子关系。

public static void main(String[] args) {

        //Object > string
        //Object > Person > Teacher
        //Object > Person > Student
        Student student = new Student();
        System.out.println(student instanceof Student);//true
        System.out.println(student instanceof Person);//true
        System.out.println(student instanceof Object);//true
        //System.out.println(student instanceof Teacher); 编译错误
        //System.out.println(student instanceof String); 编译错误

    }

3.类型转换

子类转换为父类，向上转型，可能会丢失自己的本来的一些方法。

父类转换为子类，向下转型：强制转换。语法如下：

//父类（高）        子类（低）
Person obj = new Student;

//将obj这个对象转换为Student类型，我们可以使用Student类型的方法
Student student = (Student) obj;
student.go();
//也能用一条语句表示
((Student) obj).go();