JAVA中的多态,接口,抽象类
多态
多态的概述及其代码体现
概述:
某一个事物,在不同时刻表现出来的不同状态。
举例: Cat c=new Cat();
Animal a=new Cat();
猫可以是猫的类型。猫 m = new 猫();
同时猫也是动物的一种,也可以把猫称为动物。动物 d = new 猫();
前提:
a:要有继承关系。
b:要有方法重写。 其实没有也是可以的,但是如果没有这个就没有意义。
c:要有父类引用指向子类对象。
父 f = new 子();
多态中的成员访问特点
a:成员变量
编译看左边,运行看左边。
b:构造方法
创建子类对象的时候,会访问父类的构造方法,对父类的数据进行初始化。
c:成员方法
编译看左边,运行看右边。
d:静态方法
编译看左边,运行看左边。
多态的好处:
a:提高了代码的维护性(继承保证)
b:提高了代码的扩展性(由多态保证)
弊端以及多态中向上转型和向下转型
不能使用子类特有的功能,需要向下转型才能用
以下展示一段代码:
public class Mytest {
public static void main(String[] args) {
Person p = new Teacher();
System.out.println(p.name);
System.out.println(p.age);
System.out.println(new Teacher().name);
System.out.println(new Teacher().age);
p.eat();
p.sleep();
Teacher teacher =(Teacher) p;
teacher.teach();
p=new Student();
p.eat();
p.sleep();
Student student= (Student) p;
student.playgames();
}
}
class Person{
String name = "然然";
int age = 22;
public void eat(){
System.out.println("吃饭");
}
public void sleep(){
System.out.println("睡觉");
}
}
class Teacher extends Person{
String name="皇帝";
int age = 28;
public void sleep(){
super.sleep();
System.out.println("老师睡觉要搂老婆");
}
public void teach(){
System.out.println("老师教书");
}
}
class Student extends Person{
public void sleep(){
super.sleep();
System.out.println("学生睡觉打呼噜");
}
public void playgames(){
System.out.println("学生打游戏");
}
}
此代码演示了多态,成员访问的特点,以及向下转型使用子类特有功能
多态的内存图解:
抽象类
抽象类的概述及其特点
概述:
在Java中,一个没有方法体的方法应该定义为抽象方法,而类中如果有抽象方法,该类必须定义为抽象类。
特点:
a:抽象类和抽象方法必须用abstract关键字修饰
抽象类格式: abstract class 类名 {}
抽象方法格式: public abstract void eat();
b:抽象类不一定有抽象方法,有抽象方法的类一定是抽象类
c:抽象类中可以有构造方法,抽象类不能进行实例化,那么要构造方法有什么作用呢?
用于子类访问父类数据时的初始化
d:抽象类不能直接实例化那么,抽象类如何实例化呢?
按照多态的方式,由具体的子类实例化。其实这也是多态的一种,抽象类多态。
e:抽象类的子类
要么是抽象类
要么重写抽象类中的所有抽象方法
抽象类的成员特点
特点:
a:成员变量:既可以是变量,也可以是常量
b:构造方法:有
用于子类访问父类数据的初始化
c:成员方法:既可以是抽象的,也可以是非抽象的
特性:
a:抽象方法 强制要求子类做的事情。
b:非抽象方法 子类继承的事情,提高代码复用性。
例:
public class Mytest2 {
public static void main(String[] args) {
Cat cat = new Cat();
cat.name = "咪咪";
cat.age = 2;
cat.run();
cat.eat();
cat.catchTheMouse();
Dog dog = new Dog();
dog.name = "小杰";
dog.age = 3;
dog.run();
dog.eat();
dog.biting();
}
}
abstract class Animal{
String name;
int age;
public void run(){
System.out.println("跑步");
}
public abstract void eat ();
}
class Cat extends Animal{
@Override
public void eat() {
System.out.println("猫吃鱼");
}
public void catchTheMouse(){
System.out.println("猫会抓老鼠");
}
}
class Dog extends Animal{
@Override
public void eat() {
System.out.println("狗吃骨头");
}
public void biting(){
System.out.println("狗会咬人");
}
}
父类Animal是一个抽象类,该类中的eat方法为抽象方法,所以子类Cat和Dog重写了eat方法
注意:
abstract会和final以及private关键字冲突,不能一起使用
接口
接口的概述及其特点
概述:
为了体现事物功能的扩展性,Java中就提供了接口来定义这些额外功能,并不给出具体实现,将来谁要使用这个功能,去实现这个接口就行了
特点:
a:接口用关键字interface表示 格式: interface 接口名 {}
b:类实现接口用implements表示 格式: class 类名 implements 接口名 {}
c:接口不能实例化
那么,接口如何实例化呢?
按照多态的方式来实例化。
d:接口的子类
a:可以是抽象类。但是意义不大。
b:可以是具体类。要重写接口中的所有抽象方法。
接口的成员特点
成员变量;只能是常量,并且是静态的。
默认修饰符:public static final
建议:自己手动给出。
构造方法:接口没有构造方法。
成员方法:只能是抽象方法。
默认修饰符:public abstract
建议:自己手动给出。
案例演示:
动物类:姓名,年龄,吃饭,睡觉。
动物培训接口:跳高
猫继承动物类
狗继承动物类
部分猫继承猫类并实现跳高接口
部分狗继承狗类并实现跳高接口
代码:
public class MyTest {
public static void main(String[] args) {
KittyCat cat = new KittyCat();
Animal an = cat;
an.name = "kitty";
an.age = 1;
System.out.println(an.name + "===" + an.age);
an.eat();
an.sleep();
JumpInterface jumpInterface = cat;
jumpInterface.jump();
System.out.println("---------------");
WangCaiDog wc = new WangCaiDog();
an = wc;
an.name = "旺财";
an.age = 3;
System.out.println(an.name + "===" + an.age);
an.sleep();
an.eat();
//WangCaiDog w= (WangCaiDog) an;
//w.lookDoor();
((WangCaiDog) an).lookDoor();
jumpInterface = wc;
jumpInterface.jump();
}
}
abstract class Animal {
public String name;
public int age;
public abstract void eat();
public abstract void sleep();
}
class KittyCat extends Cat implements JumpInterface{
@Override
public void eat() {
System.out.println("kitty猫吃蛋糕");
}
@Override
public void sleep() {
System.out.println("kitty猫整体睡觉");
}
@Override
public void jump() {
System.out.println("kitty猫学会跳高了");
}
}
class WangCaiDog extends Dog implements JumpInterface{
@Override
public void eat() {
System.out.println("旺财吃的是狗粮");
}
@Override
public void sleep() {
System.out.println("旺财晚上睡觉");
}
public void lookDoor(){
System.out.println("旺财看门");
}
@Override
public void jump() {
System.out.println("旺财学会里跳高");
}
}
interface JumpInterface {
void jump();
}
类与类,类与接口,接口与接口的关系
A:类与类,类与接口,接口与接口的关系
a:类与类:
继承关系,只能单继承,可以多层继承。
b:类与接口:
实现关系,可以单实现,也可以多实现。
并且还可以在继承一个类的同时实现多个接口。
c:接口与接口:
继承关系,可以单继承,也可以多继承。
抽象类和接口的区别
A:成员区别
抽象类:
成员变量:可以变量,也可以常量
构造方法:有
成员方法:可以抽象,也可以非抽象
接口:
成员变量:只可以常量
成员方法:只可以抽象
B:关系区别
类与类
继承,单继承
类与接口
实现,单实现,多实现
接口与接口
继承,单继承,多继承
C:设计理念区别
抽象类 被继承体现的是:”is a”的关系。 抽象类中定义的是该继承体系的共性功能。
接口 被实现体现的是:”like a”的关系。 接口中定义的是该继承体系的扩展功能
总结:主要学习了JAVA中的多态,接口,抽象类,以及他们各自之间的区别。这些都是JAVA中的比较重要的东西,要通过反复的练习才能掌握。