面向对象三大特征 封装、继承和多态

面向对象三大特征

构造器

类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下几个特点:

• 必须和类的名字相同
• 必须没有返回类型,也不能写void
• 不能被 static final abstract 修饰。构造方法不能被子类继承，用于初始化一个新建的对象

注：

假如在一个构造方法中使用了this语句，那么它必须作为构造方法的第一条语句。

如果用户没有提供任何的构造方法，那么Java虚拟机将会自动提供一个隐含的构造方法。

构造方法

构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法。

格式:
public类名称(参数类型参数名称){

方法体
}

注意事项:
1．构造方法的名称必须和所在的类名称完全一样，就连大小写也要一样

2．构造方法不要写返回值类型,连void都不写

3.构造方法不能return一个具体的返回值

4.如果没有编写任何构造方法，那么编译器将会默认赠送一个构造方法，没有参数，方法体也没有任何内容

public Student(){}

5.一旦编写了至少一个构造方法那么编译器将不会再赠送

6.构造方法可以进行重载（方法名相同，参数列表不同的方法，叫做重载方法）

重载构造方法

public class Student {

    //属性：字段
    private String name; //
    private int age; //
    // 构造方法
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("二参构造");
        System.out.println(name);
        System.out.println(age);
    }

    public Student(String name) {
        this(name,0);        //  调用了Student(String name, int age)构造方法
        System.out.println("名字 含参构造");
        System.out.println(name);
        System.out.println(age);
    }

    public Student() {
        this(null);          //  调用了Student(String name)构造方法
        System.out.println("无参构造");
        System.out.println(name);
        System.out.println(age);
    }
    // get set 方法
    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    /* //方法
    public void study(){
        System.out.println(this.name+"在学习");

    }*/
}

//分割线============================================================================分割线

public class TextStudent {

    public static void main(String[] args) {
        Student student1 = new Student();

        System.out.println("======================");

        Student student2 = new Student("dong");

        System.out.println("======================");

        Student student3 = new Student("zhu",20);

        /*
        结果：
        二参构造
        null
        0
        名字 含参构造
        null
        0
        无参构造
        null
        0
        
        ======================
        
        二参构造
                dong
        0
        名字 含参构造
        dong
        0
        
        ======================
        
        二参构造
                zhu
        20*/

    }

}

子类调用父类的构造方法

封装

封装就是将一些细节信息隐藏起来，让其对于外界不可见

封装在Java中的体现：

1. 方法就是一种封装
2. 关键字private也是一种封装

private

作用：对需要保护的成员变量进行修饰

private修饰后的成员变量在本类中仍然能够被访问，可是一旦超出本类在其他类中将不能被直接访问，但可以被间接访问

间接访问：通过在模板类中创建get和set方法来达到间接访问的目的

get和set方法

例如：定义了一个学生类

get方法可以在其他类中获取成员变量的值

set方法可以在其他类中设置成员变量的值

public class Student extends Person {

    private String name;
    private String sex;
    private int age;
    private String id;
    // get和set方法
    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

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

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
    // 无参构造
    public Student() {
    }
    // 有参构造（全参构造）
    public Student(String name, String sex, int age, String id) {
        this.name = name;
        this.sex = sex;
        this.age = age;
        this.id = id;
    }
}

get与set方法不仅有获取与设置成员变量的值得作用，并且可以在用set方法时，对设置的值进行限制，让其变得合法化。

如：年龄设置，你可以再set方法中加一个if else 语句阻止设置出例如负数或太大的数据出现

public void setAge(int age) {
    if (age<100&&age >0){
    this.age = age;
    }else {
        System.out.println("您输入的数值不合理");
    }
}

注

1 . 对于Getter来说，不能有参数,返回值类型和成员变量对应;

​ 对于setter来说，不能有返回值，参数类型和成员变量对应。

2 . 对于数据类型为boolean（布尔类型）的成员变量，其get和set方法有些不一样

​ set方法不变，名字照常为 setXxx;但是get方法命名就不一样了不再是getXxx而是改为了isXxx

3 . get和set方法的IDEA快捷键

​ alt+Insert之后选择 Geter and Seter 之后选择要构造的参数最后点OK

继承

继承是多态的前提，没有继承就没有多态 继承主要解决：共性抽取这一问题

父类：也可以叫基类，超类

子类：也可以叫派生类

继承的特点

1. 子类可以拥有父类的“内容”
2. 子类也可以拥有自己的专有内容

在继承关系中，“子类就是一个父类”。也就是说，子类可以被当做父类看待。

继承的格式：

定义父类的格式：（与普通类相同）

public class Fu {

    public void method(){
        System.out.println("fulei");

    }

}

定义子类的格式：

public class Zi extends Fu{
    
    @Override
    public void method() {
        System.out.println("zilei");
    }
    
}

一、在父子类的继承关系中，如果成员变量重名，则创建子类对象时，访问的两种方式：

1. 直接通过子类对象访问成员变量：等号左边是谁，则优先用谁，没有则向上找。
2. 间接通过成员方法访问成员变量：该方法属于谁，就优先用谁，没有则向上找

二、三种位置处的成员变量表示：

1. 本类方法中的局部变量： 直接写变量名输出
2. 本类的成员变量：this.成员变量名
3. 父类的成员变量：super.成员变量名

代码示例：

public class Fu {
    int num = 10;
}

public class Zi extends Fu{
    int num = 20;

    public void method(){
        int num = 30;
        System.out.println(num);
        System.out.println(this.num);
        System.out.println(super.num);
    }
}

public class ExtendsField {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.method();
    }
}

三、在父子类的继承关系中，如果成员方法重名，则创建子类对象时，访问成员方法的规则：

创建的对象是谁，就优先用谁，如果没有则向上找。

注意事项：无论是成员方法还是成员变量，如果没有都是向上找父类，绝对不会向下找子类

继承中方法的重写

概念：在继承关系中，方法的名称一样，参数列表也一样

重载和重写的区别：

重写（Override）: 方法的名称一样，参数列表也一样。也叫覆盖，覆写

重载（Overload）: 方法的名称一样，参数列表不一样

方法覆盖重写的特点：创建的是子类对象，则优先使用子类的方法

方法覆盖重写的注意事项：

1. 必须保证父子类之间方法的名称相同，参数列表也相同。@Override ：写在方法的前边，用来检测是不是有效的正确覆盖重写。（不是必须要写，这个注解就算不写，只要满足要求，也是正确的方法覆盖重写）。
2. 子类方法的返回值必须小于等于父类方法的返回值范围。 扩展：java.lang.Object类是所有类的公共最高父类，java.lang.String就是Object的子类。
3. 子类方法的权限修饰符必须大于等于父类方法的权限修饰符。 扩展： public > protected > (default) > private

注：（default）不是关键字default，而是什么都不写，留空。

四、继承关系中，父子类构造方法的访问特点：

1. 子类构造方法当中有一个默认隐含的“super（）”调用，所以一定是先调用的父类构造，后执行的子类构造
2. 子类构造可以通过super关键字来调用父类重载构造
3. super的父类构造调用，必须是子类构造的第一个语句。不能一个子类构造调用多次super构造
4. 总结：子类不许调用父类构造方法，不写则赠送super（）；写了则用写的指定的super调用，super只能有一个，还必须是第一个，放在第一行。

Java继承的三个特点

1. Java语言是单继承的，一个类的直接父类只能有唯一一个
2. Java语言可以多级继承
3. 一个子类的直接父类是唯一的，但是一个父类可以拥有多个子类

多态

对象的多态性

extends和implements 都可以作为多态的前提

多态的格式与使用

代码当中体现多态性，其实就是一句话：父类引用指向子类对象。

格式： 左侧父类的引用，指向右侧子类的对象
父类名称 对象名 = new 子类名称();
或者：
接口名称 对象名 = new 实现类名称()

成员变量的使用

1. 直接通过子类对象访问成员变量：等号左边是谁，则优先用谁，没有则向上找。
2. 间接通过成员方法访问成员变量：该方法属于谁，就优先用谁，没有则向上找

成员方法的使用

成员方法的访问规则：

看new的是谁，就优先用谁，没有则向上找

口诀：编译看左边，运行看右边

成员变量与成员方法的区别：

成员变量：编译看左边，运行还看左边。
成员方法：编译看左边，运行看右边。

    public class Demo02MultiMethod {

        public static void main(String[] args) {
            Fu obj = new Zi(); // 多态

            obj.method(); // 父子都有，优先用子
            obj.methodFu(); // 子类没有，父类有，向上找到父类

            // 编译看左边，左边是Fu，Fu当中没有methodZi方法，所以编译报错。
//        obj.methodZi(); // 错误写法！
        }

    }

对象的向上转型

父类引用指向子类对象

格式： 父类名称 对象名 = new 子类名称（）； Animal animal =new Cat();

含义： 右侧创建一个子类对象，把他当做父类来使用。

注： 向上转型一定是安全的。从小范围转向了大范围，例：从小范围的猫转换为了大范围的动物。

类似于：

double num = 100; // int -->double,自动类型转换

对象的向下转型

向上转型一定是安全的，没有问题的，正确的。但是也有一个弊端：
对象一旦向上转型为父类，那么就无法调用子类原本特有的内容。

解决方案：用对象的向下转型【还原】。

格式：子类名称 对象名 = （子类名称）父类对象

含义：将父类对象还原成为本来的子类对象

Animal animal = new Cat; // 本来为猫类，向上转型为了动物类

Cat cat =(Cat)animal; // 将动物类还原成为本来的猫类

注意事项：

1. 必须保证对象本来创建的时候，就是猫，才能向下转型为猫
2. 如果对象创建的时候本来不是猫，现在要向下转型为猫，就会报错（编译不会报错，运行会出现异常 java.lang.ClassCastException : 类转换异常）

instanceof

如何才能知道一个父类引用的对象，本来是什么子类？
格式：
对象 instanceof 类名称
这将会得到一个boolean值结果，也就是判断前面的对象能不能当做后面类型的实例。