JavaSE基础学习day2--继承多态

public class AnimalDemo{
    public static void main(String[]args){
        //向上转型
        Animal a=new Cat();
        //向下转型
        Cat c=(Cat)a;
        c.eat();
        c.playGame();
        //向上转型
        a=new Dog();
        a.eat();
        //向下转型
        Cat cc=(Cat)a;
    }
}

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

public class Cat extends Animal{
    public void eat(){
        System.out.println("猫吃鱼");
    }
    public void playGame(){
        System.out.println("猫捉老鼠");
    }
}
public class Dog extends Animal{
    public void eat(){
        System.out.println("狗吃肉");
    }
}

a.main方法新建Animal对象，由于cat继承Animal，故a的地址值为001

b.a.eat（）执行看右边，即cat类的eat方法入栈，输出相应内容

c.a被强制转换为cat类后赋给新的cat c，由于类相同且同继承一个父类，所以可以转换成功，a的地址值将传给c，继续执行到方法后输出相应内容

d. 由于Dog类是对Animal类的继承，故新的对象可以赋给a（向上转型），此时新的对象在堆内存中开辟空间，地址值为002，并将地址传给a

e.执行a.eat（）

f.执行向下转型时发现a指向的002地址值，即Dog类的对象，但是在转化赋值后给的是cat类对象，此时出现类型转换异常

总结：只能有继承关系的两个类或者同类之间可以转化，其他的继承类与本继承类无法转化

3.抽象类

3.1抽象类概述

在Java中，一个没有方法体的方法应该被定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类

抽象方法（没有方法体）：public abstract void eat（）；

3.2 抽象类的访问特点

抽象类的抽象方法必须使用abstract关键字修饰
抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
抽象类的实例化：参照多态的方式，通过子类实例化（抽象多态）
抽象类的子类要么重写抽象类中所有的抽象方法，要么是抽象类

3.3 抽象类的成员特点

成员变量：常量/变量
构造方法：有构造方法但无法实例化，构造方法用于子类访问父类数据的初始化
成员方法：可以有抽象方法但子类必须完成这些操作，也可以有非抽象方法为了提高代码复用性（继承）

4.接口

4.1接口概述

接口就是一种公共的规范标准，只要符合规范标准，大家都可以使用

Java中的接口更多的体现在对行为的抽象

4.2 接口的特点

接口用关键字interface修饰：public interface 接口名{}
类实现接口用implements：public class 类名 implements 接口名{}
接口不能实例化：参照多态（接口多态）
接口的实现类：要么重写接口中的所有抽象方法，要么是抽象类

4.3 接口的成员特点

成员变量：只能是常量，默认修饰符：public static final
构造方法：接口没有构造方法
成员方法：只能是抽象方法，默认修饰符：public abstract

4.4 类和接口的关系

类和类的关系：继承关系，只能单继承，不能多层继承
类和接口的关系：实现关系，可以单实现，也可以多实现，还可以在一个类同时实现多个接口
接口和接口的关系：继承关系，可以单继承，也可以多继承

4.5 抽象类和接口的区别

成员区别：

抽象类：变量、常量、有构造方法、有抽象方法、也有非抽象方法

接口：常量、抽象方法

关系区别：

类和类的关系：继承关系，只能单继承，不能多层继承

类和接口的关系：实现关系，可以单实现，也可以多实现

接口和接口的关系：继承关系，可以单继承，也可以多继承

设计理念区别：

抽象类：对类抽象，包括属性、行为

接口：对行为抽象，主要是行为

总结：抽象类是对事物的抽象，接口是对行为的抽象

4.6 案例

现在有乒乓球运动员和篮球运动员，乒乓球教练和篮球教练。为了出国交流，跟乒乓球相关的人员都要学习英语，用代码实现

设计思路：

分析：从具体到抽象
实现：从抽象到具体
使用：使用的是具体的类的对象

//说英语的接口
public interface SperkEnglish{
    public abstract void speak();
}
//抽象人类
public abstract class Person{
    private String name;
    private int age;
    public Person(){}
    public Person(String name,int age){
        this.name=name;
        this.age=age;
    }
    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age=age;
    }
    public int getAge(){
        return age;
    }
    public abstract void eat();
}
//抽象教练类
public abstract class Coach extends Person{
    public Coach(){}
    public Coach(String name,int age){
        super(name,age);           
    }
    public abstract void teach();
}
//抽象运动员类
public abstract class Player extends Person{
    public Player(){}
    public Player(String name,int age){
        super(name,age);           
    }
    public abstract void learn();
}
//具体乒乓球运动员类
public class PingPongPlayer extends Player{
    @Override
    public void learn(){
        System.out.println("乒乓球运动员学下旋球");
    }
    @Override
    public void eat(){
        System.out.println("乒乓球运动员吃蔬菜");
    }
}
//具体的乒乓球教练类
public class PingPongCoach extends Coach{
    @Override
    public void teach(){
        System.out.println("乒乓球教练教下旋球");
    }
    @Override
    public void learn(){
        System.out.println("乒乓球运动员学下旋球");
    }
}
//具体的篮球运动员类{
    @Override
    public void learn(){
        System.out.println("篮球运动员学精准投篮");
    }
    @Override
    public void eat(){
        System.out.println("篮球运动员吃羊肉");
    }
}
//具体的篮球教练类{
    @Override
    public void teach(){
        System.out.println("篮球教练教精准投篮");
    }
    @Override
    public void eat(){
        System.out.println("篮球教练吃水果");
    }

}
public class PersonDemo{
    public static void main(String[]args){
        //创建对象
        PingPongPlayer ppp=new PingPongPlayer();
        ppp.setName("Nick");
        ppp.setAge(20);
        System.out.println(ppp.getName()+","+ppp.getAge());
        ppp.eat();
        ppp.study();
        ppp.speak();
        System.out.println("-------------");

        BasketballPlayer bbb=new BasketballPlayer();
        bbb.setName("Jack");
        bbb.setAge(21);
        System.out.println(bbb.getName()+","+bbb.getAge());
        bbb.eat();
        bbb.study();
        bbb.speak();
     
        
    }
}

5*.形参和返回值

5.1 类名作为形参和返回值

方法的形参是类名，其实需要的是该类的对象
方法的返回值是类名，其实返回的是该类的对象

5.2 抽象类名作为形参和返回值

方法的形参是抽象类名，其实需要的是该抽象类子类的对象
方法的返回值是抽象类名，其实返回的是该抽象类子类的对象

5.3 接口名作为形参和返回值

方法的形参是接口名，其实需要的是该接口的实现类的对象
方法的返回值是接口名，其实返回的是该接口的实现类的对象

6.内部类

6.1 内部类概述

内部类：在一个类中定义一个类

内部类的定义格式：

public class 类名{

修饰符 class 类名{

}

}

内部类的访问特点：

内部类可以直接访问外部类的成员，包括私有
外部类要访问内部类的成员，必须创建对象

public class Outer{
    private int num=10;
    public class Inner{
        public void show(){
            System.out.println(num);//10        
        }
    }
    public void method(){
        //show();//不可以
        Inner i=new Inner();
        i.show();//即可
        
    }
}

6.2 成员内部类

按照内部类在类中定义的位置不同，可以分为以下两种形式

再类的成员位置：成员内部类
在类的局部位置：局部内部类

成员内部类修饰符为public，外界的公共创建方法

格式：外部类名.内部类名对象名=外部类对象.内部类对象；
比如：Outer.Inner oi=new Outer().Inner()；

成员内部类修饰符为private，外界的私有创建方法

在外部类中定义一个方法（定义内部类的对象，并调用内部类方法），方法中创建了内部类对象，在外界类中直接用外部类的对象调用该方法即可访问内部类的方法

public class Outer{
    private int num=10;
    private class Inner{
        public void show(){
            System.out.println(num);
        }
    }

    public void method(){
        Inner i=new Inner();
        i.show();
    }
}

public class T2{
    public static void main(String[]args){
        Outer o=new Outer();
        o.method();
    }
}

6.3 局部内部类

局部内部类是在方法中定义的类，所以外界是无法直接使用，需要在方法内部创建对象并使用

该类可以直接访问外部类的成员，也可以访问方法内的局部变量

public class Outer{
    private int num=10;

    public void method(){
        int num2=20;
         class Inner{
           public void show(){
            System.out.println(num);
            }
        }
        Inner i=new Inner();
        i.show();
    }
}

public class T2{
    public static void main(String[]args){
        Outer o=new Outer();
        o.method();
    }
}

6.4 匿名内部类

前提：存在一个类或者接口，这里的类可以是具体类也可以是抽象类

格式：

new 类名或者接口名(){

重写方法；

}

本质：是一个继承了该类或者实现了该接口的子类匿名对象

//Inter是一个接口
public class Outer{
    public void method(){
        new Inter(){
            @Override
            public void show(){
                System.out.println("匿名类的对象：");
            }
        };//本质是一个对象 
    }
}

public class T2{
    public static void main(String[]args){
        Outer o=new Outer();
        o.method();
    }
}

此时控制台没有任何结果，如果想要调用show方法

new Inter(){
            @Override
            public void show(){
                System.out.println("匿名类的对象：");
            }
        }.show();即可调用该方法

如果要多次调用：new Inter（）{}是一个内部类对象，方法体是一个实现类对象，可以用多态的思想赋值给接口类对象，用接口类对象调用实现类方法即可

Inter i=new Inter(){
            @Override
            public void show(){
                System.out.println("匿名类的对象：");
            }
        }；

实际在开发中，如果要创建多个类才能实现接口的方法，则可以直接用匿名内部类实现需求

yz不摆烂24124

关注

28
点赞
踩
28

收藏

觉得还不错? 一键收藏
打赏
2
评论
JavaSE基础学习day2--继承多态

继承和多态的相关内容
复制链接

扫一扫

JavaSE基础学习day2--继承多态

1.继承

1.1 继承概述

1.2 继承的好处和弊端

1.3 super关键字

1.4 继承中构造方法的访问特点

1.5 继承中成员方法的访问特点

1.6 super内存图

1.7 方法重写

1.8 Java中继承的注意事项

1.9 修饰符

1.9.1 权限修饰符

1.9.2 状态修饰符

final关键字

static关键字

2.多态

2.1 多态概述

2.2多态中成员访问特点

2.3 多态的好处和弊端

2.4 多态的转型

2.5 多态转型的内存图