1.封装

1.封装的概念

封装：将类的某些信息隐藏在类内部，不允许外部程序直接访问， 而是通过该类提供的方法来实现对隐藏信息的操作和访问 。

2.封装的好处

3. 具体实现

–属性使用private权限
–方法使用public权限

如上图所示,在Demo类中的name属性被private关键字修饰,所以在test2类中即使创建对象也无法直接调用name属性.

public class Test2 {
    public static void main(String[] args) {
        Demo d = new Demo();
        d.setName("法外狂徒张三");
        System.out.println(d.getName());
    }
}
 class Demo {
    private String name;

    public String getName() {
        return name;
    }

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

2.继承

1.什么是继承?

(1) 继承是面向对象程序设计不可缺少的设计思想，是实现代码可重 用的根
基，是提高代码可扩展性的主要途径。

(2) 继承是从已有的类中派生出新的类，新的类能吸收已有类的属性和行
为， 并能扩展新的能力。

例如: 儿子 继承 父亲
优点: 儿子可以使用父亲的功能 提高代码的复用性

2.java中的继承

1. 在Java中用extends关键字继承

2. 在java中一个类只可能有一个父类,不允许一个类继承多个类

3. 继承之后子类可以调用父类的所有非私有属性和非私有方法

3.什么时候使用继承?

这里所说的继承其实与现实生活中的继承很类似

比如儿子和父亲,儿子是子类,父亲是父类,父亲的家产啥的就像父类的所有属性和方法,而上面说的"非私有属性和非私有方法"就相当于是父亲允许儿子可以用的家产,即就是不被private关键字修饰属性和方法

再比如,狗属于动物,猫也属于动物,就可以使用继承

1. 继承是代码重用的一种方式
2. 符合is-a关系的设计,使用继承
3. 将子类共有的属性和行为放到父类中

4.具体实现

public class Test2 {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.eat();
        Dog dog = new Dog();
        dog.eat();
    }

}

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

class Cat extends Animal {

}

class Dog extends Animal {

}

结果如下:

5.继承中的构造方法

1. 子类构造方法总是先调用父类构造方法,默认情况下，调用父类无参构造方法 可以在子类构造方法的第一行，使用super关键字调用父类任意一个构造方法 如果用super,必须写在构造方法的第一句

2. 如果子类的构造方法中没有显式地调用基类构造方法，则系统默认调用基类无 参数的构造方法。

public class Test2 {
    public static void main(String[] args) {
        Cat cat = new Cat();
    }
}

class Animal {
    String name;
    
    public Animal() {
        this.name = "法外狂徒张三";
        System.out.println(this.name);
    }

    public Animal(String name) {
        this.name = name;
        System.out.println(this.name);
    }

    public void eat() {
        System.out.println("我在吃饭");
    }
}

class Cat extends Animal {

}

结果如下:

public class Test2 {
    public static void main(String[] args) {
        Cat cat = new Cat();
    }

}

class Animal {
    String name;

    public Animal() {
        this.name = "法外狂徒张三";
        System.out.println(this.name);
    }

    public Animal(String name) {
        this.name = name;
        System.out.println(this.name);
    }

    public void eat() {
        System.out.println("我在吃饭");
    }
}

class Cat extends Animal {
   public Cat(){
       super("罗翔老师");
   }
}

结果如下:

6.方法的重写(OverRide)

1. 应用场景:当父类的方法实现不能满足子类需求时,可以对方法进行重写

2. 在子类中可以根据需要对从基类中继承来的方法进行重写

3. 方法重写规则
   (1) 方法名相同、参数列表相同；
   (2) 返回值类型相同；
   (3) 访问权限不能小于父类权限;

注意：构造方法,静态方法不能重写,成员变量不存在重写

public class Test2 {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.eat();
    }

}

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

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

结果如下:

7.补充内容

1. 专业术语(了解知道即可)

Dog类是 Animal类的子类, Animal类是Dog类的父类
Dog类是 Animal类的派生类, Animal类是Dog类的基类

2. 继承的传递性

C类从B类继承,B类又从A类继承 那么C类就具有B类和A类的所有非私有属性和非私有方法

当一个没有继承任何一个类时,jvm会默认让类继承Object类 Object是 java为所有类提供的基类

3.多态

1.多态的概念

同一种事物，在不同时刻表现不同的状态

2. 多态存在的三个必要条件

1. 要有继承（包括接口的实现）(前提条件)
2. 要有重写(前提条件)
3. 父类引用指向子类对象

3.多态环境下对各种方法的调用

1.多态环境下对成员方法的调用

简单的说：编译看左边，运行看右边

public class Test2 {
    public static void main(String[] args) {
        Animal cat = new Cat();
        cat.eat();//调用的是子类中的方法
    }

}

class Animal {

    public void eat() {
        System.out.println("我在吃饭");
    }
}

class Cat extends Animal {

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

结果如下:

2.多态环境下对静态成员方法的调用

简单的说：编译和运行都看左边

public class Test2 {
    public static void main(String[] args) {
        Animal cat = new Cat();
        cat.eat();//调用的是动物类中的静态成员方法。
    }

}

class Animal {

    public static void eat() {
        System.out.println("我在吃饭");
    }
}

class Cat extends Animal {

    public  static void eat() {
        System.out.println("猫咪在吃鱼");
    }
}

结果如下:

3.多态环境下对成员变量的调用

简单的说：编译和运行都看等号左边。

public class Test2 {
    public static void main(String[] args) {
        Animal cat = new Cat();
        System.out.println(cat.name);//调用的是动物类中的成员变量。
    }

}

class Animal {
    String name="法外狂徒张三";
}

class Cat extends Animal {
    String name="罗翔老师";
}

结果如下:

注意：变量不存在被子类覆写这一说法，只有方法存在覆写。

4.方法参数具有的多态性

1.什么是方法参数的多态性

方法参数的多态性即就是方法的形式参数类型是父类类型，而传递的实际参数可以是任意子类的对象

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

        Test2 test2 = new Test2();
        Cat cat = new Cat();
        test2.method(cat);
        Dog dog = new Dog();
        test2.method(dog);
    }
    //方法的形式参数类型是父类类型，而传递的实际参数可以是任意子类的对象
   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("狗狗吃骨头");
    }
}

结果如下:

2.方法参数的多态性的好处

方法参数多态性的好处：提高代码的扩展性

5.多态的转型

1.向上转型

1.向上转型的概念

向上转型就是用父类的的变量来接收子类的对象
只能使用父类中的方法
不能使用子类中的方法

public class Test2 {
    public static void main(String[] args) {
        Animal dog = new Dog();//向上造型，Dog对象提升到Animal对象
        dog.look();//只能使用父类中的方法 
        dog.eat();//报错！不能使用子类中的方法
    }
}

class Animal {

    public void look() {
        System.out.println("狗狗看大门");
    }
}


class Dog extends Animal {

    public void eat() {
        System.out.println("狗狗吃骨头");
    }
}

写代码时的报错照片

2.向上转型的好处

向上转型的作用是：提高程序的扩展性。

2.向下转型

1.向下转型的概念

向下转型就是先用父类的的变量来接收子类的对象,再将父类变量转化为子类变量
可以使用父类中的方法
可以使用子类中的方法

public class Test2 {
    public static void main(String[] args) {
        Animal dog = new Dog();//向上造型，Dog对象提升到Animal对象
        Dog dog1 =(Dog)dog;//将父类变量转化为子类变量
        dog1.look();//可以使用父类中的方法
        dog1.eat();//可以使用子类中的方法
    }
}

class Animal {

    public void look() {
        System.out.println("狗狗看大门");
    }
}


class Dog extends Animal {

    public void eat() {
        System.out.println("狗狗吃骨头");
    }
}

2.向下转型的好处

向下转型的作用是：为了使用子类中的特有方法。

最后，觉得有用的话，可以点赞、收藏，加关注哟，要不下次就找不见了哟！