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

一、封装

1.1 private关键字

        private是一个权限修饰符，可以修饰成员（成员变量和成员方法） 作用是保护成员不被别的类使用，被private修饰的成员只在本类中才能访问，即成员私有化

        针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作：

        提供“get变量名()”方法，用于获取成员变量的值，方法用public修饰

        提供“set变量名(参数)”方法，用于设置成员变量的值，方法用public修饰

1.1.1 private关键字的使用

        一个标准类的编写： 把成员变量用private修饰，提供对应的getXxx()/setXxx()方法

1.2 this关键字

        this修饰的变量用于指代成员变量，方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量；方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量。解决局部变量隐藏成员变量的时候需要用this关键字。

        this：代表所在类的对象引用，方法被哪个对象调用，this就代表哪个对象

1.3 封装

1.3.1 概述

        封装是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的

1.3.2 封装原则

        将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问 成员变量private，提供对应的getXxx()/setXxx()方法

1.3.3 封装的好处

        通过方法来控制成员变量的操作，提高了代码的安全性，把代码用方法进行封装，提高了代码的复用性

class Test{//封装
    private int name;//private将变量私有化修饰，外部不能直接访问变量

    public Test(){}

    public Test(int name){
        this.name = name;//this.name指代Test中的name变量，等号后面的name为方法接收的形参
    }

    public int getName() {
        return name;
    }

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

    private void show(){//private将方法私有化修饰，外部不能直接访问方法
        System.out.println("hello");
    }
}

二、继承

1. 继承的概述

        继承可以使得子类具有父类的属性和方法，还可以在子类中重新定义，以及追加属性和方法。通过extends关键字实现继承。

        格式： class 子类 extends 父类 { }

//继承
public class Person{
    private String name;
    private int age;

    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 class Student extends Person{//Student继承了Person类
    public void study(){
        System.out.println("学习");
    }
}

2. 继承的好处和弊端

        好处：继承可以让类与类之间产生关系，即子父类关系，产生子父类关系后，子类则可以使用父类中非私有的成员。提高了代码的复用性(多个类相同的成员可以放到同一个类中)，提高了代码的维护性(如果方法的代码需要修改，修改一处即可)。

        弊端：继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性。

3. 应用场景

        使用继承，需要考虑类与类之间是否存在is..a的关系，不能盲目使用继承

        is..a的关系：谁是谁的一种

4. 继承中访问特点

        变量访问：在子类方法中访问一个变量，采用的是就近原则。 子类局部范围找——子类成员范围找——父类成员范围找——如果都没有就报错(不考虑父亲的父亲…)。

        构造方法访问：子类中所有的构造方法默认都会访问父类中无参的构造方法，子类初始化之前，一定要先完成父类数据的初始化。每一个子类构造方法的第一条语句默认都是：super()

        成员方法访问：通过子类对象访问一个方法，子类成员范围找——父类成员范围找——如果都没有就报错(不考虑父亲的父亲…)。

//继承中访问特点
public class Fu {
    //年龄
    public int age = 40;
}

public class Zi extends Fu {
    //身高
    public int height = 175;

    //年龄
    public int age = 20;

    public void show() {
        int age = 30;
        System.out.println(age);
        System.out.println(height);
        //报错,父类没有wight变量
//        System.out.println(weight);
    }
}

/*
    测试类
 */
public class Demo {
    public static void main(String[] args) {
        //创建对象，调用方法
        Zi z = new Zi();
        z.show();
    }
}

5. super关键字

        super：代表父类存储空间的标识(可以理解为父类对象引用)

this和super的使用分别

        成员变量：     

        this.成员变量——访问本类成员变量

        super.成员变量——访问父类成员变量

        成员方法：

        this.成员方法——访问本类成员方法

        super.成员方法——访问父类成员方法

        构造方法：

        this(…)——访问本类构造方法

        super(…)——访问父类构造方法

//继承中super关键字的使用
public class Fu {
    public int age = 40;
}

public class Zi extends Fu {
    public int age = 20;

    public void show() {
        int age = 30;
        System.out.println(age);
        //访问本类的成员变量age
        System.out.println(this.age);
        //访问父类的成员变量age
        System.out.println(super.age);
    }
}

/*
    测试类
 */
public class Demo {
    public static void main(String[] args) {
        //创建对象，调用方法
        Zi z = new Zi();
        z.show();
    }
}

6. 方法重写

        概念：子类出现了和父类中一模一样的方法声明（方法名一样，参数列表也必须一样）

        应用场景：当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。

        Override注解：用来检测当前的方法，是否是重写的方法，起到【校验】的作用

        注意事项：

        1. 私有方法不能被重写(父类私有成员子类是不能继承的)

         2. 子类方法访问权限不能更低(public > 默认 > 私有)

//继承的方法重写
public class Fu {

    public Fu() {}

    public Fu(int age) {
        System.out.println("Fu中带参构造方法被调用");
    }
}

public class Zi extends Fu {

    public Zi() {
//        super();子类中构造方法默认第一句为super();，即调用父类无参构造方法
//        super(20);可以调用父类的带参构造方法
        System.out.println("Zi中无参构造方法被调用");
    }

    public Zi(int age) {
        System.out.println("Zi中带参构造方法被调用");
    }
}

/*
    测试类
*/
public class Demo {
    public static void main(String[] args) {
        //创建对象
        Zi z = new Zi();
        Zi z2 = new Zi(20);
    }
}

7. 注意事项

        Java中类只支持单继承，不支持多继承
        错误范例：class A extends B, C { }

        Java中类支持多层继承

        正确范例：     

        class A {}       

        class B extends A{ }       

        class C extends B{ }

三、多态

1. 多态概述

        概述：同一个对象，在不同时刻表现出来的不同形态

        多态的前提条件：

        1.有继承/实现关系
        2.有方法重写
        3.有父(类/接口)引用指向(子/实现)类对象

//多态
public class Animal{
    public void eat(){
        System.out.println("动物吃东西");
    }
}

public class Cat extends Animal{
    @Override
    public void eat(){
        System.out.println("猫吃老鼠");
    }
}

public class Test01{
    public static void main(String[] args) {
        Animal a = new Cat();
    }
}

2. 成员访问特点

        成员变量访问：编译看左边、运行看左边

        成员方法访问：编译看左边、运行看右边

//多态成员访问特点
public class Animal {

    public int age = 40;

    public void eat() {
        System.out.println("动物吃东西");
    }
}

public class Cat extends Animal {

    public int age = 20;
    public int weight = 10;

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    public void playGame() {
        System.out.println("猫捉迷藏");
    }
}

/*
    测试类
 */
public class AnimalDemo {
    public static void main(String[] args) {
        //有父类引用指向子类对象
        Animal a = new Cat();

        System.out.println(a.age);//输出结果为40，即编译运行都看左边
//        System.out.println(a.weight);weight不能调用，因为Animal类中没有

        a.eat();//输出结果为"猫吃鱼"，即编译看左边，运行看右边
//        a.playGame();不能调用，父类中没有此方法
    }
}

3. 好处和弊端

        好处：提高了代码的扩展性。定义方法时，如果将父类型作为参数，在使用方法时，可以传递任意子类对象

        弊端：不能使用子类特有的成员

4. 转型

        向上转型：从子到父，父类引用指向子类对象
        例：Animal a = new Cat()

        向下转型：从父到子，父类引用转为子类对象
        子类 对象名 = (子类)父类引用;

//多态中的转型
public class Animal {

    public void eat() {
        System.out.println("动物吃东西");
    }
}

public class Cat extends Animal {

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    public void playGame() {
        System.out.println("猫捉迷藏");
    }
}

public class AnimalDemo {
    public static void main(String[] args) {
        //多态
        Animal a = new Cat(); //向上转型
        a.eat();

        /*
        //创建Cat类的对象
        Cat c = new Cat();
        c.eat();
        c.playGame();
        */

        //向下转型
        Cat c = (Cat)a;
        c.eat();
        c.playGame();
    }
}