JAVASE基础模块（多态 抽象类 接口等）
多态
-
指的是一种事物 在不同时刻所表现出的不同状态
- 猫是猫类 也是动物类
- Cat cat=newCat(); Animal animal=new Animal();
-
多态的前提
- 要有继承 没有继承 多态就不存在
- 要有方法重写 不重写多态就失去了意义
- 多态是父类引用指向子类对象
-
多态的形式 来观察成员变量的特点
- 编译看左边 运行看右边
- 编译看父类有没有这个方法 有语法就报错 实际调用时 以子类重写过的方法为准
public class DuoTai { public static void main(String[] args) { Cat a = new Cat(); a.eat(); a.show(); System.out.println(a.age); Animal a1 = new Cat(); a1.eat(); System.out.println(a1.age); a1.show(); } } class Animal { int age = 5; public void eat() { System.out.println("吃东子"); } public void show() { System.out.println("爸爸"); } } class Cat extends Animal { int age = 2; public void eat() { System.out.println("猫爱吃鱼"); } @Override public void show() { System.out.println("儿子女儿"); } } 运行结果： 猫爱吃鱼 儿子女儿 2 猫爱吃鱼 5 儿子女儿 Process finished with exit code 0- 多态的形式访问成员变量 访问的都是父类的变量
- 静态方法多态 依然遵循父类
-
多态的好处
- 提高代码的扩展性
- 提高代码的维护性
package com.westos.x0;
import com.westos.Test;
public class Dt {
public static void main(String[] args) {
C c = new C();
Test.testAnimal(c);
D d = new D();
Test.testAnimal(d);
}
}
package com.westos.x0;
public class A {
public void eat() {
System.out.println("吃东子");
}
}
package com.westos.x0;
public class C extends A {
@Override
public void eat() {
super.eat();
System.out.println("猫爱吃鱼");
}
}
package com.westos.x0;
public class D extends A {
@Override
public void eat() {
super.eat();
System.out.println("狗不理");
}
}
package com.westos;
import com.westos.x0.A;
public class Test {
private Test() {
}
public static void testAnimal( A an) {
an.eat();
}
}
运行结果：
吃东子
猫爱吃鱼
吃东子
狗不理
Process finished with exit code 0
- 父类引用指向了类对象
- 多态形式调用成员吃饭方法
- 多态的弊端 不能调用子类特有的功能
- 通过向下转型解决此问题
孔子装爹
- Java培训特别火,很多人来请孔子爹去讲课，这一天孔子爹被请走了 但是还有人来请，就剩孔子在家玩游戏，价格还挺高。孔子一想，我是不是可以考虑去呢? 然后就穿上爹的衣服，带上爹的眼睛，粘上爹的胡子 就开始装爹 实际讲的是论语 讲完之后 回到家 觉得假扮太累了 所以卸下装扮 做回他自己 愉快的玩游戏去了
public class Die {
int age=68;
public void teach(){
System.out.println("传授JAVA");
}
}
public class KongZi extends Die{
int age=68;
public void teach(){
System.out.println("贴胡子");
System.out.println("换衣服");
System.out.println("假装爹去传授lol");
}
public void game(){
System.out.println("玩游戏");
}
}
public class KunZiZhuangDie {
public static void main(String[] args) {
Die kongzi=new KongZi();
System.out.println(kongzi.age);
kongzi.teach();
KongZi kz=(KongZi) kongzi;
kz.game();
}
}
运行结果：
68
贴胡子
换衣服
假装爹去传授lol
玩游戏
Process finished with exit code 0
- 向上转型 父类引用指向子对象
抽象类
-
抽取所有子类的共性功能 但是不给出 共性功能的具体实现 而是交给子类根据自身的特性做不同的具体实现
-
abstract 抽象 可以修饰类 可以修饰方法
-
抽象类的语法特点
-
抽象类中 可以没有抽象方法 也可以有抽象方法
-
一个类中 一旦有了抽象方法 此类就必须为抽象类
-
抽象类是不能直接实例化的 但是 我们可以采用多态的形式来间接实例化
public class Test { public static void main(String[] args) { Fu fu=new Zi(); } } abstract class Fu{ int num=33; final int numx=777; public Fu(){ System.out.println("爸爸的构造方法"); } } class Zi extends Fu { public Zi() { System.out.println("爸爸的构造方法"); } } 运行结果： 爸爸的构造方法 儿子的构造方法 Process finished with exit code 0 -
抽象类中的所有抽象方法 强制子类必须重写
-
抽象类的子类 有两种选择
- 选择一 重写抽象类中的所有抽象方法
- 选择二 将子类自身设为抽象类 不推荐
-
抽象方法有无都合理的原因
- 非抽象方法 子类直接继承使用 提高代码的复用性
- 抽象方法 子类必须重写 强制要求子类做的事情
public class ChouXiang { public static void main(String[] args) { Cat cat = new Cat(); cat.eat(); cat.sleep(); Dog dog = new Dog(); dog.eat(); dog.sleep(); } } abstract class Animal { public abstract void eat(); public abstract void sleep(); } class Cat extends Animal { @Override public void eat() { System.out.println("探鱼"); } @Override public void sleep() { System.out.println("白天睡觉"); } } class Dog extends Animal { @Override public void eat() { System.out.println("排骨"); } @Override public void sleep() { System.out.println("晚上睡觉"); } } 运行结果： 探鱼 白天睡觉 排骨 晚上睡觉 Process finished with exit code 0 -
-
抽象类有构造方法 作用：用于子类访问父类数据时的初始化
public abstract class Person {
public abstract void eat();
public abstract void sleep();
}
public class Teacher extends Person {
@Override
public void eat() {
System.out.println("老师爱吃清汤面");
}
@Override
public void sleep() {
System.out.println("晚上早早睡觉");
}
public void zaoCan() {
System.out.println("早起做早餐");
}
}
public class Student extends Person {
@Override
public void eat() {
System.out.println("学生爱吃排骨");
}
@Override
public void sleep() {
System.out.println("晚上不睡觉");
}
public void game() {
System.out.println("熬夜打游戏");
}
}
public class MyTest {
public static void main(String[] args) {
Person p=new Teacher();
p.eat();
p.sleep();
((Teacher)p).zaoCan();
Person s=new Student();
s.eat();
s.sleep();
((Student)s).game();
}
}
运行结果：
老师爱吃清汤面
晚上早早睡觉
早起做早餐
学生爱吃排骨
晚上不睡觉
熬夜打游戏
Process finished with exit code 0
- 父类并不清楚子类吃饭功能的具体实现 所以没必要给出共性功能的具体实现
- 抽象类无法实例化对象
-
员工与经理实例
public class Ren { public static void main(String[] args) { Person p = new Employee("马化某", 1001, 5000); System.out.println(p.getName()); System.out.println(p.getNum()); System.out.println(p.getSalary()); ((Employee)p).lei(); p.work(); Person x = new Manager("丁某", 6666, 15000, 6000); System.out.println(x.getName()); System.out.println(x.getNum()); System.out.println(x.getSalary()); ((Manager)x).hun(); x.work(); } } abstract class Person { private String name; private int num; private double salary; public Person() { } public Person(String name, int num, double salary) { this.name = name; this.num = num; this.salary = salary; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getNum() { return num; } public void setNum(int num) { this.num = num; } public double getSalary() { return salary; } public void setSalary(double salary) { this.salary = salary; } public abstract void work(); } class Employee extends Person { public Employee(String name, int num, double salary) { super(name, num, salary); } @Override public void work() { System.out.println("上班混日子 就为拿工资"); } public void lei() { System.out.println("累成傻狗"); } } class Manager extends Person { private double bonus; public Manager(String name, int num, double salary, double bonus) { super(name, num, salary); this.bonus = bonus; } @Override public void work() { System.out.println("公司耍威风 舒服"); } public void hun() { System.out.println("出差混日子"); } } 运行结果： 马化某 1001 5000.0 累成傻狗 上班混日子 就为拿工资 丁某 6666 15000.0 出差混日子 公司耍威风 舒服 Process finished with exit code 0
一：一个类没有抽象方法设置成抽象类的原因是 不想让外界创建这个类的对象
二：final private static与abstract不能共存
- final 方法子类不能重写
- private 不能继承 无法重写
- static 方法不参与重写
接口
-
接口 是为了定义一些额外扩展的的功能 哪些事物想要具备这些功能 可以对接口进行实现
-
接口的特点
- 接口不能实例化
-
接口的子类有两种选择
- 重写接口中的所有方法
- 可以是抽象类 但是意义不大
-
接口中的成员特点
-
接口中的成员变量 全部都是公共的静态常量 前面存在默认修饰符 public static final
-
JDK1.7之前接口中的方法 全部都是抽象方法 不存在非抽象方法 方法前面默认 public abstract
-
JDK1.8之后 允许给出方法的具体实现 但是这个方法得用default来修饰 同时也允许接口中定义静态方法
public interface MyInterface { public default void game (){ System.out.println("Tom猫打游戏很帅"); }} -
接口中没有构造方法
-
接口不能实例化
-
-
类与类之间的关系 extends 继承关系 并且是单继承
-
类与接口之间的关系 implement 实现关系 并且可以多实现
public abstract class Animal {
public abstract void eat();
public abstract void sleep();
public abstract void work();
}
public interface MyInterface {
public abstract void game ();
}
public class TomCat extends Animal implements MyInterface {
@Override
public void eat() {
System.out.println("Tom猫吃骨头");
}
@Override
public void sleep() {
System.out.println("Tom猫熬夜");
}
@Override
public void work() {
System.out.println("Tom猫懒得工作");
}
public void game() {
System.out.println("Tom猫打游戏很帅");
}
}
public class Cat extends Animal {
@Override
public void eat() {
System.out.println("吃鱼");
}
@Override
public void sleep() {
System.out.println("睡觉");
}
@Override
public void work() {
System.out.println("被伺候");
}
}
public class Testxdxd {
public static void main(String[] args) {
Animal a=new Cat();
a.eat();
a.work();
a.sleep();
Animal a1=new TomCat();
a1.eat();
a1.work();
a1.sleep();
MyInterface myInterface= (MyInterface) a1;
((MyInterface) a1).game();
}
}
运行结果：
吃鱼
被伺候
睡觉
Tom猫吃骨头
Tom猫懒得工作
Tom猫熬夜
Tom猫打游戏很帅
Process finished with exit code 0