封装继承多态

封装

什么是封装

指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

封装原则

将不需要对外提供的内容都隐藏起来，把属性隐藏，提供公共方法对其访问。

private（私有）关键字

特点

1. 是一个权限修饰符
2. 可以修饰成员变量和成员方法
3. 被其修饰的成员只能在本类中被访问

this关键字

特点

代表当前对象的引用

案例

class Cat2{
    private String name;
    private int age;
    private String color;

    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 String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    @Override
    public String toString() {
        return "Cat2{" +
                "name='" + name + '\'' +
                ", age='" + age + '\'' +
                ", color='" + color + '\'' +
                '}';
    }
    
    //无参构造
    public Cat2() {
    }

	//有参构造
    public Cat2(String name, int age, String color) {
        this.name = name;
        this.age = age;
        this.color = color;
    }

    public void message(){
        System.out.println(this.name+" "+this.age+" "+this.color);
    }
}

继承

概念

让类和类之间产生父子关系，同时子类可以拥有父类的所有非私有属性和行为（方法）

语法

子类 extends 父类

注意事项

1. 对于java而言，是不允许存在多继承的
2. java中继承是传递性的
3. java中所有类的顶级父类，都是Object（对象） 要么直接继承，要么间接继承(了解即可)
4. 子类只能继承父类所有非私有的成员（成员变量、成员方法）
5. 子类不能继承父类的构造方法，但是可以通过super关键字去访问父类的构造方法

案例

public class Test02 {
    public static void main(String[] args) {
        Ordinary ordinary = new Ordinary();
        ordinary.wage_print(300,30);

        Manager manager = new Manager();
        manager.wage_print(611  ,21);
    }
}


/*
 * 员工类
 */
class Employee{
    int salary;     //单日工资
    int days;       //工作天数
    final float level = 1.0F;  //工作等级

    //工资打印
    public void wage_print(int salary,int days){
        float num = (float) (salary * days * level);
        System.out.println(num);
    }
}

/*
 * 普通员工
 */
class Ordinary extends Employee{
}

/*
 * 部门经理
 */
class Manager extends Employee{
    final float level = 1.2F;
    public void wage_print(int salary, int days) {
        float num = (float) (1000 + salary * days * level);
        System.out.println(num);
    }
}

多态

java中多态需满足的条件（3个）

1. 要有继承关系（有2个或者2个以上的类）
2. 有方法重写（子类继承了父类的方法，但是不想用父类的方法体，就可以做方法重写）
3. 向上造型（父类引用指向子类对象）

多态的注意事项

1. 多态中对成员变量的访问规则：编译看左边（父类），运行看左边（父类）
2. 多态中对成员方法的访问规则：编译看左边（父类），运行看右边（子类）
3. 多态中对静态方法的访问规则：编译看左边（父类），运行看左边（父类）注意：多态中的静态方法，不能算是方法重写
4. 不能使用子类的特有属性和行为

案例

/*
* 多态
*/
public class TestDemo01 {
    public static void main(String[] args) {
        method(new Cat());
        method(new Dog());
    }

    /*
    * Animal animal = ？？？
    * 动态加载
    */
    public static void method(Animal animal){
        animal.eat();
    }
}

class Animal{
    public void eat(){
        System.out.println("吃饭");
    }
}

class Cat extends Animal{
    public void eat(){
        System.out.println("吃猫粮");
    }
}

class Dog extends Animal{
    public void eat(){
        System.out.println("吃狗粮");
    }
}