01. 多态访问静态方法
-
代码实现
/** * 多态 * @author 海锋 * */ public class Demo01_Polymorphic { public static void main(String[] args) { //父类引用指向子类对象 Father01 clazz01 = new Son01(); //成员方法 //编译看左边，运行看右边。（方法重写） clazz01.show1(); System.out.println("----------------"); //静态方法 //编译看左边，运行看左边。（静态方法不是一个重写的方法，所以不支持动态绑定） clazz01.show2(); } } class Father01 { public void show1() { System.out.println("father show"); } public void show2() { System.out.println("father static show"); } } class Son01 extends Father01 { @Override public void show1() { System.out.println("son show"); } @Override public void show2() { System.out.println("son static show"); } } -
总结
- 编译看左边，运行看右边
- 静态方法是无法进行重写的
02. 多态的好处和弊端
-
代码实现
/** * 多态的应用 * @author 海锋 * */ public class Demo02_Polymorphic { public static void main(String[] args) { new FruitJuiceFactory().juice(new Apple("苹果")); } } class FruitJuiceFactory { public void juice(Fruit fruit) { System.out.println("正在榨" + fruit.getName() + "汁儿~~~"); } } class Fruit { private String name; public Fruit() { super(); } public Fruit(String name) { super(); this.name = name; } public String getName() { return name; } public void setName(String name) { this.name = name; } } class Apple extends Fruit{ public Apple() { super(); } public Apple(String name) { super(name); } } class Banana extends Fruit { public Banana() { super(); } public Banana(String name) { super(name); } } class Orange extends Fruit { public Orange() { super(); } public Orange(String name) { super(name); } } -
多态好处
- 提高了代码的复用性
- 提高了代码的扩展性
-
多态坏处
- 无法访问子类的特有成员
03. 多态中的类型转换
- 向上转型
- 自动类型提升
- 将一个对象的类型有子类型转换为父类型
- 向下转型
- 强制类型转换
- 将一个对象类型由父类型转换为子类型
- 注意事项
- 多态中类型转换，需要具有子父类关系
04. 多态访问成员的特点
- 多态访问成员变量
- 编译看左边，运行看左边
- 如果编译不通过，那么程序报错；如果编译通过，那么就执行
- 多态访问成员方法
- 编译看左边，运行看右边
- 如果编译不通过，那么程序报错；如果编译通过，那么就执行
- 多态访问静态成员方法
- 编译看左边，运行看左边
- 如果编译不通过，那么程序报错；如果编译通过，那么就执行
05. 抽象类的概述
-
抽象类概述
- 定义一个类，如果某一个行为是看不懂的，那么该类就该被定义为一个抽象类
-
语法
-
使用abstract关键字
public abstract class 类名 { 数据类型 变量名; public abstract 返回值类型 方法名(参数类型 参数名1, 参数类型 参数名2...); }
-
-
抽象类特点
-
抽象类不一定有抽象方法
-
有抽象方法的类一定是抽象类
-
抽象类不能直接创建对象
- 使用多态的方式来穿件抽象类对象
-
抽象类的子类
- 抽象子类
- 可以重写父类的抽象方法，也可以不重写父类的抽象方法
- 具体子类
- 必须重写父类的所有抽象方法
- 抽象子类
-
代码实现
abstract class Animal{ public abstract void eat(); public abstract void walk(); } /** * eat依然是抽象的 * @author qiuzhiwei * */ abstract class Person extends Animal{ @Override public void walk() { System.out.println("两条腿走路"); } } class Chinese extends Person{ @Override public void eat() { System.out.println("吃米饭"); } }
-
06. 抽象类的成员特点
- 总结
- 成员变量
- 可以是变量，也可以是常量
- 不能用abstract修饰
- 成员方法
- 可以是抽象的，也可以是非抽象的
- 构造器
- 可以有构造器
- 成员变量
07. 抽象类练习之猫狗问题
public class Demo03_Abstract {
public static void main(String[] args) {
Cat1 cat1 = new Cat1("橘猫",1);
cat1.catchMouse();
cat1.eat();
}
}
public abstract class Animal1 {
private String name;
private int age;
public Animal1() {
super();
}
public Animal1(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public abstract void eat();
public abstract void walk();
public abstract void talk();
}
public class Cat1 extends Animal1 {
public Cat1() {
super();
}
public Cat1(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println("吃猫粮");
}
@Override
public void walk() {
System.out.println("跳跃");
}
@Override
public void talk() {
System.out.println("喵喵喵");
}
public void catchMouse() {
System.out.println("抓老鼠");
}
}
08. 抽象类练习之学校老师问题
public class Demo04_Abstract {
public static void main(String[] args) {
ChineseTeacher chineseTeacher = new ChineseTeacher("张芷若",18);
chineseTeacher.eat();
chineseTeacher.teach();
}
}
public abstract class Teacher {
private String name;
private int age;
public Teacher() {
super();
}
public Teacher(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void eat() {
System.out.println("吃米饭");
}
public abstract void teach();
}
public class MathTeacher extends Teacher{
public MathTeacher() {
super();
}
public MathTeacher(String name, int age) {
super(name, age);
}
@Override
public void teach() {
System.out.println("教数学");
}
}
public class ChineseTeacher extends Teacher{
public ChineseTeacher() {
super();
}
public ChineseTeacher(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println("吃满汉全席、佛跳墙");
}
@Override
public void teach() {
System.out.println("教中文");
}
}
09. abstract关键字注意事项
- 如果一个类中没有抽象方法，但是依然使用abstract关键字修饰该类，有什么用？
- 让该类不能直接创建对象，而是通过多态的形式进行实例化
- abstract不能喝哪些关键字共存？
- static
- 第一角度：使用static修饰的方法，可以直接使用类名.调用，而直接使用类名.调用的话，该抽象方法依然没有具体化
- 第二角度：使用static修饰的方法，不能进行方法重写，方法无法具体化
- final
- 使用final修饰的方法，不能进行方法重写
- private
- 使用private修饰的方法，不能别继承，导致不能进行方法重写
- static
10. 接口
-
接口概述
- 从狭义的角度就是interface
- 从广义的角度讲对外提供规则的都是接口
-
语法
interface 接口名{ public abstract 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...); } -
接口特点
- 类与接口之间是实现关系
- 接口也不能直接实例化
- 通过多态的方式来实例化
- 接口的子类
- 抽象子类
- 普通子类
-
接口的成员特点
- 成员变量
- 只能是常量，不能是变量
- 而且java会默认补全public static final 修饰符
- 构造器
- 没有构造器
- 接口中没有变量需求进行初始化
- 成员方法
- 只能是抽象方法
- 而且java会默认补全public abstract 修饰符
- 成员变量
11. 类与类、类与接口、接口与接口
- 类与类
- 继承关系
- 只能单继承，可以多层继承
- 类与接口
- 实现关系
- 可以单实现，也可以多实现
- 接口与接口
- 继承关系
- 可以单继承，也可以多继承，也可以多层继承
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
