多态的概述
- 多态概述
某一个事物,在不同时刻表现出来的不同状态。
举例: Cat c=new Cat();
Animal a=new Cat();
猫可以是猫的类型。猫 m = new 猫();
同时猫也是动物的一种,也可以把猫称为动物。动物 d = new 猫(); - 多态前提
a:要有继承关系。
b:要有方法重写。 其实没有也是可以的,但是如果没有这个就没有意义。
c:要有父类引用指向子类对象。
父 f = new 子();
public class MyTest {
public static void main(String[] args) {
//继承是多态的前提。
//多态:指的是某个事物,在某个时刻,所表现出来的不同状态
//多态的三个必要条件
//1.要有继承
//2.要有方法重写,可以没有,但是多态就没有意义
//3.父类引用指向子类对象
//Cat cat = new Cat();
//cat.sleep();
//cat.eat();
// Animal anima=new Animal();
//多态,父类引用指向的是子类对象
Animal an=new Cat();
an.sleep();
an.eat();
an.show();
}
}
class Animal{
public void eat(){
System.out.println("吃饭");
}
public void sleep() {
System.out.println("睡觉");
}
public void show() {
System.out.println("父类中的show方法");
}
}
class Cat extends Animal{
@Override
public void eat() {
System.out.println("猫爱吃鱼");
}
@Override
public void sleep() {
System.out.println("猫爱白天睡觉");
}
}
多态中的成员访问特点
- 多态中的成员访问特点
a:成员变量
编译看左边,运行看左边。
b:构造方法
创建子类对象的时候,会访问父类的构造方法,对父类的数据进行初始化。
c:成员方法
编译看左边,运行看右边。
d:静态方法
编译看左边,运行看左边。
(静态和类相关,算不上重写,所以,访问还是左边的)
public class MyTest {
public static void main(String[] args) {
//以多态的形式来访问成员变量 使用的还是父类的变量
//编译看左边,运行也看左边
Fu fu = new Zi();
System.out.println(fu.num);
//多态的形式访问成员方法 编译看左边,运行看右边
//
fu.show();
Fu.hehe();
}
}
class Fu{
int num = 100;
public void show(){
System.out.println("父类的show方法");
}
public static void hehe(){
System.out.println("父类的静态方法");
}
}
class Zi extends Fu{
int num=10;
@Override
public void show() {
System.out.println("子类重写过后的show方法");
}
public static void hehe() {
System.out.println("子类的静态方法");
}
}
多态的好处和弊端
- 多态的好处
a:提高了代码的维护性(继承保证)
b:提高了代码的扩展性(由多态保证)
public class MyTest {
public static void main(String[] args) {
//多态的好处,提高了代码的扩展性
//多态的弊端,不能访问子类独有的功能和属性
Fu fu = new Zi();
System.out.println(fu.a);
//System.out.println(fu.num);
fu.show();
//父类引用不能直接访问子类独有的方法
// fu.test();
//我们可以向下转型
Zi zi= (Zi) fu; //向下转型
System.out.println(zi.num);
zi.test();
}
}
class Fu{
int a=10;
public void show(){
System.out.println("父类的show方法");
}
}
class Zi extends Fu{
int num=10;
@Override
public void show() {
System.out.println("子类重写了父类的show方法");
}
public void test(){
System.out.println("子类一个特有的方法");
}
}
- 通过多态的弊端引出问题
不能使用子类特有的功能 - 解决问题
把父类的引用强制转换为子类的引用。(向下转型)
public class MyTest {
public static void main(String[] args) {
Cat cat = new Cat();
Animal an=cat; //多态就是向上转型
an.eat();
//an.cacheMouse();
Cat c= (Cat) an; //向下转型
c.eat();
c.cacheMouse();
Dog dog = new Dog();
an=dog;
Dog d= (Dog) an; //向下转型
d.lookDoor();
an.eat();
// an=new Tiger();
Tiger t= (Tiger) an;
//ClassCastException 类型转换异常
t.goSwimming();
}
}
class Animal{
public void eat(){
System.out.println("吃饭");
}
}
class Cat extends Animal{
@Override
public void eat() {
System.out.println("猫吃鱼");
}
public void cacheMouse(){
System.out.println("猫抓老鼠");
}
}
class Dog extends Animal{
@Override
public void eat() {
System.out.println("狗吃骨头");
}
public void lookDoor(){
System.out.println("狗看门");
}
}
class Tiger extends Animal{
@Override
public void eat() {
System.out.println("老虎不吃素");
}
public void goSwimming(){
System.out.println("老虎去游泳");
}
}
抽象类的概述及特点
- 在Java中,一个没有方法体的方法应该定义为抽象方法,而类中如果有抽象方法,该类必须定义为抽象类。
- 抽象类特点
a:抽象类和抽象方法必须用abstract关键字修饰
抽象类格式: abstract class 类名 {}
抽象方法格式: public abstract void eat();
b:抽象类不一定有抽象方法,有抽象方法的类一定是抽象类
c:抽象类中可以有构造方法,抽象类不能进行实例化,那么要构造方法有什么作用呢?
用于子类访问父类数据时的初始化
d:抽象类不能直接实例化那么,抽象类如何实例化呢?
按照多态的方式,由具体的子类实例化。其实这也是多态的一种,抽象类多态。
e:抽象类的子类
要么是抽象类
要么重写抽象类中的所有抽象方法
抽象类的成员特点
- 抽象类的成员特点
a:成员变量:既可以是变量,也可以是常量。
b:构造方法:有。
用于子类访问父类数据的初始化。
c:成员方法:既可以是抽象的,也可以是非抽象的。 - 抽象类的成员方法特性:
a:抽象方法 强制要求子类做的事情。
b:非抽象方法 子类继承的事情,提高代码复用性。
public class MyTest5 {
public static void main(String[] args) {
//假如我们在开发一个系统时需要对员工(Employee) 类进行设计,员工包含3个属性:姓名、工号以及工资(salary)。
//经理(Manager) 也是员工,除了含有员工的属性外,另为还有一个奖金(bonus) 属性。
//然后定义工作的方法.
// 请使用继承的思想设计出员工类和经理类。
Person p = new Employee();
p.name="小张";
p.num=1;
p.salary=2000;
System.out.println(p.name+"=="+p.num+"==="+p.salary);
p.work();
System.out.println("--------------------");
p=new Manager();
p.name = "老王";
p.num = 2;
p.salary = 4000;
((Manager) p).bonus=2000;
System.out.println(p.name+"==="+((Manager) p).bonus+"==="+p.num);
p.work();
}
}
abstract class Person {
public String name;
public int num;
public double salary;
public abstract void work();
}
class Manager extends Person {
public double bonus;
@Override
public void work() {
System.out.println("经理管理员工");
}
}
class Employee extends Person{
@Override
public void work() {
System.out.println("员工敲代码");
}
}
接口的概述及特点
-
接口的概述:为了体现事物的功能的扩展性,java中就提供了接口来定义这些额外功能,并不给出具体实现,只需要将这些额外功能实现即可。
-
接口特点
a:接口用关键字interface表示 格式: interface 接口名 {}
b:类实现接口用implements表示 格式: class 类名 implements 接口名 {}
c:接口不能实例化
那么,接口如何实例化呢?
按照多态的方式来实例化。
d:接口的子类
a:可以是抽象类。但是意义不大。
b:可以是具体类。要重写接口中的所有抽象方法。接口的成员特点
接口成员特点
成员变量;只能是常量,并且是静态的。
默认修饰符:public static final
建议:自己手动给出。
构造方法:接口没有构造方法。
成员方法:只能是抽象方法。
默认修饰符:public abstract
建议:自己手动给出。
抽象类和接口的区别
- 成员区别
抽象类:
成员变量:可以变量,也可以常量
构造方法:有
成员方法:可以抽象,也可以非抽象
接口:
成员变量:只可以常量
成员方法:只可以抽象 - 关系区别
类与类
继承,单继承
类与接口
实现,单实现,多实现
接口与接口
继承,单继承,多继承 - 设计理念区别
抽象类 被继承体现的是:”is a”的关系。 抽象类中定义的是该继承体系的共性功能。
接口 被实现体现的是:”like a”的关系。 接口中定义的是该继承体系的扩展功能。