继承 多态 向上转型 向下转型

一、什么是继承

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。当然，如果在父类中拥有私有属性(private修饰)，则子类是不能被继承的。

1.继承的特点

1. 只支持单继承：一个子类只允许有一个父类。
2. 子类可以拥有父类的属性和方法：子类继承了父类，就会拥有父类中的非私有属性和方法。
3. 子类可以拥有自己的属性和方法：子类除了继承父类的属性和方法外，还可以定义自己独有的属性和方法。
4. 子类可以重写覆盖父类的方法：子类可以对父类中的方法进行重写覆盖，以实现自己的功能。
5. 支持多层继承：Java支持多层继承，即一个类可以继承另一个类，而这个类又可以继承另一个类，以此类推，形成继承体系。

2.继承的使用

 继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。当然，如果在父类中拥有私有属性(private修饰)，则子类是不能被继承的。

2.1继承的格式

class 父类 {
    ...
} 
 
class 子类 extends 父类 {
    ...
}

 2.2继承的演示

//Employee.java
class Employee {//父类
    String name;
    public void work(){
        System.out.println("好好工作");
    }
}


//Teacher.java
class Teacher extends Employee{
    public void printfName(){
        System.out.println("name="+this.name);
    }
}

///Demo1.java
public class Demo1 {
    public static void main(String[] args) {
        Teacher teacher=new Teacher();
        teacher.name="hao";
       // System.out.println(teacher.name);
        teacher.printfName();
        teacher.work();

//  结果   
//        name=hao
//        好好工作
    }
}

3 this和super的作用 

//fu.java
public class Fu {
    int num=5;
}


//zi.java
public class Zi extends Fu {//继承父类
    int num=6;
    public void show(){
        System.out.println("fu num="+num);
        System.out.println("zi num="+num);//只能看到子类的num
            结果
//        fu num=6
//        zi num=6    


        System.out.println("zi num="+super.num);//父类的num
        System.out.println("zi num="+this.num);//子类的num
            结果
//        fu num=5
//        zi num=6    
    }
}


//Demotest.java
public class Demotest {
    public static void main(String[] args) {
        Zi z=new Zi();//创建子类对象
        z.show();//调用子类对象的show方法，展示num


    }
}

4方法的重写 

  方法重写 ：子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写。声明不变，重新实现。

//Phone.java
手机基本功能
public class Phone {
    public void sendMessage(){
        System.out.println("发短信");
    }
    public void call(){
        System.out.println("打电话");
    }
    public void showNum(){
        System.out.println("来电是显示号码");
    }
}


//newphone.java

public class Newphone extends Phone{
    public void showNum(){
        super.showNum();//用super调用父类已经存在的方法

        System.out.println("显示来电头像");//在子类类方法里调用父类并且增加新功能
    }
}


//Demo2test
public class Demo2test {
    public static void main(String[] args) {
        Newphone np=new Newphone();
        
        np.call();// 调用父类继承而来的方法

        np.showNum();// 调用子类重写的方法
    
        打电话
        来电是显示号码
        显示来电头像
    }
}

2.5 继承构造

//
public class Fu {
    private int n;
    Fu(){
        System.out.println("Fu构造");
    }
}

///
public class Zi extends Fu {
    Zi(){
        super();
        System.out.println("zi构造");
    }
}

public class Demo3test {
    public static void main(String[] args) {
        Zi zi=new Zi();
   //创建了新的子类，就会默认给子类构造（进行初始化），
        如果是继承了父类就会先对父类进行（构造）初始化

 结果
        Fu构造
        zi构造

    }
}

二、什么是多态

多态是同一个行为具有多个不同表现形式或形态的能力。

1.多态的特点

1. 消除类型之间的耦合关系，实现低耦合
2. 灵活性
3. 可扩充性
4. 可替换性

2.多态的使用

public abstract class Animal {// 抽象类 Animal
    public abstract void eat();// 抽象方法 eat

    public void makeSound(){
        System.out.println("The animal makes a sound");
    }
}

/
public class Cat extends Animal {
    public void eat(){
        System.out.println("Cat is eating 吃鱼");
    }
}

/
public class Dog extends Animal {//继承一个抽象类，必须要在里面重写父类的一个方法
    @Override
    public void eat(){
        System.out.println("Dog is eating 吃肉");
    }
}

/

public class demotest {//用于演示多态

    public static void main(String[] args) {

        Cat a=new Cat();//Cat is eating 吃鱼
        Dog b=new Dog();//Dog is eating 吃肉

        showAnimalEat(a);//Cat is eating 吃鱼
        showAnimalEat(b);//Dog is eating 吃肉
        /*
        以上,以下两个方法, 均可以被showAnimalEat(Animal a)方法所替代
        而执行效果一致
        */
    }

    public static void showcatEat(Cat a){
        a.eat();
    }
    public static void showdogEat(Dog b){
        b.eat();
    }


    public static void showAnimalEat(Animal a){
        a.eat();
    }


    public static void main1(String[] args) {
        Animal[] animals=new Animal[2];//创建一个animals类型的数组
        animals[0]=new Dog();//父类类型 变量名 = new 子类对象；
        animals[1]=new Cat();//向上转型，Dog对象赋值给Animal类型的变量

        for(Animal animal:animals){
            animal.eat();
            animal.makeSound();

            //Dog is eating.
            //The animal makes a sound
            //Cat is eating
            //The animal makes a sound
        }
    }
}

3.向上转型和向下转型使用

向上转型

 父类类型 变量名 = new 子类类型();
如：Animal a = new Cat();

 向下转型

 子类类型 变量名 = (子类类型) 父类变量名;
如:Cat c =(Cat) a;

public class Animal {
    public void makeSound(){
        System.out.println("the animal makes a sound");
    }
}

///

public class Dog extends Animal{
    @Override
    public void makeSound(){
        System.out.println("the dog bark");
    }
    public void playball(){
        System.out.println("play ball");
    }
}

///

public class AnimalHandler {//定义AnimalHandler类，包含handleAnimals方法
    public void handleAnimals(Animal[] animals){//
        for(Animal animal: animals){//foreach循环
            if(animal instanceof Dog){ // 检查是否是Dog对象
                Dog dog=(Dog)animal;// 向下转型为Dog对象
                dog.playball();// 调用Dog类特有的方法
            }else{
                animal.makeSound(); // 对于其他Animal对象，调用通用方法
            }
        }
    }
}

///

public class test {
    public static void main(String[] args) {
        Animal[] animals=new Animal[2];
        animals[0]=new Dog();//向上转型
        animals[1]=new Animal(); 直接赋值Animal类型的对象
        for(Animal a:animals){
            a.makeSound();
// 调用makeSound方法，如果是Dog对象，则执行Dog类的makeSound实现
//如果是父类animal就执行父类的makeSound方法

结果
// the dog bark
// the animal makes a sound
        }
    }

}



public class test1 {
    public static void main(String[] args) {
        // 创建Animal数组，包含Dog和其他Animal对象
        Animal [] animals={new Dog(),new Animal(),new Dog()};
        // 创建AnimalHandler对象
        AnimalHandler animalHandler=new AnimalHandler();
        // 调用handleAnimals方法,将数组名传进去
        animalHandler.handleAnimals(animals);


         结果
        //play ball
        //the animal makes a sound
        //play ball
    }
}

以上就是小编总结的知识点啦，如果对你有帮助请三连奥