面向对象三大特征之三:多态
什么是多态?
多态是在继承/实现情况下的一种现象,表现为:对象多态、行为多态。
多态的前提是:有继承/实现关系;存在父类引用子类对象;存在方法重写。
多态是对象、行为的多态,Java中的属性(成员变量)不谈多态。
package com.itchinajie.d1_polymorphism;
public class Test {
public static void main(String[] args) {
//目标:认识多态:对象多态、行为多态
//1、对象多态
People p1 = new Student();
p1.run();//识别技巧:编译看左边,运行看右边
System.out.println(p1.name);//注意:对于变量,编译看左边,运行看左边
People p2 = new Teacher();
p2.run();//识别技巧:编译看左边,运行看右边
System.out.println(p2.name);//注意:对于变量,编译看左边,运行看左边
}
}
package com.itchinajie.d1_polymorphism;
//父类
public class People {
public String name = "父类People的名称";
public void run(){
System.out.println("人可以跑~~");
}
}
package com.itchinajie.d1_polymorphism;
public class Student extends People{
public String name = "子类Student的名称";
@Override
public void run(){
System.out.println("学生跑的贼快~~");
}
}
package com.itchinajie.d1_polymorphism;
public class Teacher extends People{
public String name = "子类Teacher的名称";
@Override
public void run(){
System.out.println("老师跑的气喘吁吁~~");
}
}
使用多态的好处
可以解耦合,扩展性更强;使用父类类型的变量作为方法的形参时可以接收一切子类对象。
但是多态下不能直接调用子类的独有方法,我们可以通过强制类型转换进行解决:
//目标:理解多态的好处
//好处1:可以实现解耦合,右边对象可以随时切换,后续业务随机改变
People p1 = new Student();
p1.run();
//p1.test();//3、弊端:多态下不能使用子类的独有功能,怎么解决
//强制类型转换
Student s1 = (Student) p1;
s1.test();
//好处2:可以使用父类类型的变量作为形参,可以接收一切子类对象。
Student s = new Student();
go(s);
Teacher t = new Teacher();
go(t);
}
public static void go(People p){
p.run();
if(p instanceof Student){
Student s = (Student) p;
s.test();
}else if (p instanceof Teacher){
Teacher t = (Teacher) p;
t.teach();
}
}
多态下类型转换的问题
编译阶段有继承或者实现关系就可以强制转换,但是运行时可能出现类型转换异常。
//强制类型转换可能存在的问题:编译阶段有继续或者实现关系就可以强制转换,但是运行时可能出现类型转换异常
//Teacher t1 = (Teacher) p1;//运行时出现了:ClassCastException
//t1.teach();
//强转前,Java建议:使用instanceof关键字,判断当前对象的真实类型,再进行强转。
if(p1 instanceof Student){
Student s2 = (Student) p1;
s2.test();
}else if (p1 instanceof Teacher){
Teacher t2 = (Teacher) p1;
t2.teach();
}
final关键字
final关键字是最终的意思,可以修饰(类、方法、变量)
修饰类:该类被称为最终类,特点是不能被继承了。
修饰方法:该方法被称为最终方法,特点是不能被重写了。
修饰变量:该变量只能被赋值一次。
final修饰变量的注意
final修饰基本类型的变量,变量存储的数据不能被改变。
filna修饰引用类型的变量,变量存储的地址不能被改变,但地址所指向对象的内容是可以被改变的。
package com.itchinajie.d3_final;
public class Test {
/*
常量:public static final修饰的成员变量,建议名称全部大写,多个单词下划线链接
*/
public static final String SCHOOL_NAME = "黑马";
private final String name= "牛逼";//这种用法没有意义
public static void main(String[] args) {
//目标:认识final的作用
//3、final可以修饰变量总规则:有且仅能赋值一次
/*变量:
* 一、局部变量
* 二、成员变量
* 1、静态成员变量
* 2、实例成员变量*/
final int a;
a = 1;
// a = 2;//第二次赋值,出错了
final double r = 3.14;
//r = 0.1;//报错
final int[] arr = {22,11,33};
//arr = null;//改地址有问题
arr[1] = 333;//该数值没问题
//SCHOOL_NAME = "白马";//报错
//t.name = "孙悟空";//报错
}
public static void buy(final double z){
//z = 1;//第二次赋值,报错
}
}
//1、final修饰类,类不能被继承了
final class A{
}
/*
class B extends A{
}
*/
//2、final修饰方法了,方法就不能被重写了
class C{
public final void test(){
}
}
class D extends C{
// @Override
// public void test() {
// super.test();
// }
}
这里有个东西叫做常量
使用了static final修饰的成员变量就被称为常量;
作用:通常用于记录系统的配置信息。
package com.itchinajie.d3_final;
public class Test2 {
//软编码
public static final String SCHOOL_NAME = "黑马程序员";
public static void main(String[] args) {
//目标:认识常量
System.out.println(SCHOOL_NAME);
System.out.println(SCHOOL_NAME);
System.out.println(SCHOOL_NAME);
System.out.println(SCHOOL_NAME);
System.out.println(SCHOOL_NAME);
/*
硬编码
System.out.println("黑马程序员");
System.out.println("黑马程序员");
System.out.println("黑马程序员");
System.out.println("黑马程序员");
System.out.println("黑马程序员");
System.out.println("黑马程序员");
*/
}
}
注意!常量名的命名规范:建议使用大写英文单词,多个单词使用下划线连接起来。
使用常量记录系统配置信息的优势、执行原理
代码可读性更好,可维护性也更好。
程序编译后,常量会被“宏替换”:出现常量的地方全部会被替换成其记住的字面量
这样可以保证使用常量和直接用字面量的性能是一样的。
抽象类
在到ava中有一个关键字叫:abstract,它就是抽象的意思,可以用它修饰类、成员方法。
abstract修饰类,这个类就是抽象类;修饰方法,这个方法就是抽象方法。
package com.itchinajie.d4_abstract;
public abstract class A {
private String name;
public static String schoolName;
public A() {
}
//抽象方法:必须用abstract修饰,只有方法签名,一定不能有方法体
public abstract void run();
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public static String getSchoolName() {
return schoolName;
}
public static void setSchoolName(String schoolName) {
A.schoolName = schoolName;
}
public A (String name){
this.name = name;
}
}
抽象类的注意事项和特点
抽象类中不一定有抽象方法,有抽象方法的类一定是抽象类。
类该有的成员(成员变量、方法、构造器)抽象类都可以有。
抽象类最主要的特点:抽象类不能创建对象,仅作为一种特殊的父类,让子类继承并实现。
一个类继承抽象类,必须重写完抽象类的全部抽象方法,否则这个类也必须定义成抽象类。
抽象类的好处
通过一个小案例来总结一下:
需求:
某宠物游戏,需要管理猫、狗的数据。
猫的数据有:名字;行为是:喵喵喵的叫~
狗的数据有:名字;行为是:汪汪汪的叫~
请用面向对象编程设计该程序。
一共创建四个类
package com.itchinajie.d5_abstract2;
public class Test {
public static void main(String[] args) {
//目标:掌握抽象类的好处
Animal a = new Cat();
a.setName("叮当猫");
a.cry();//更好的支持了多态
}
}
Animal抽象类
package com.itchinajie.d5_abstract2;
public abstract class Animal {
private String name;
public abstract void cry();
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
package com.itchinajie.d5_abstract2;
import com.itchinajie.d4_abstract.A;
public class Cat extends Animal{
@Override
public void cry(){
System.out.println(getName() + "喵喵喵的叫~~");
}
}
package com.itchinajie.d5_abstract2;
public class Dog extends Animal{
@Override
public void cry(){
System.out.println(getName() + "汪汪汪的叫~~");
}
}
父类知道每个子类都要做某个行为,但每个子类要做的情况不一样,父类就定义成抽象方法,交给子类去重写实现,我们设计这样的抽象类,就是为了更好的支持多态。
建议使用finals关键字修饰模板方法,为什么?
模板方法是给对象直接使用的,不能被子类重写。
一旦子类重写了模板方法,模板方法就失效了。
抽象类的常见应用场景:模板方法设计模式
模板方法设计模式解决了什么问题?
解决方法中存在重复代码的问题。
模板方法设计模式的写法
1、定义一个抽象类。
2、在里面定义2个方法
一个是模板方法:把相同代码放里面去。
一个是抽象方法:具体实现交给子类完成。
package com.itchinajie.d6_abstact_temp;
public class Test {
//目标:搞清楚抽象类的应用场景之一,经常用来设计模板方法设计模式
//场景:学生,老师都要写一篇作文:我的爸爸
//第一段是一样的
//正文部分自由发挥
//最后一一段也是一样的
public static void main(String[] args) {
Teacher t = new Teacher();
t.write();
}
}
package com.itchinajie.d6_abstact_temp;
public abstract class People {
/*
* 设计一个模板方法设计模式
* 1、定义一个模板方法出来
* */
public void write(){
System.out.println("\t\t\t\t\t《我的爸爸》");
System.out.println("\t\t我的爸爸好啊,牛逼啊,来看我的爸爸有多牛");
//2、模板方法并不清楚正文部分到底应该怎么写,但是他知道子类肯定要写
System.out.println(writeMain());
System.out.println("有这样的爸爸太好了");
}
//3、设计一个抽象方法写正文,具体的实例交给子类来完成
public abstract String writeMain();
}
package com.itchinajie.d6_abstact_temp;
public class Student extends People{
@Override
public String writeMain(){
return "我的爸爸特别牛,我开车都不看红绿灯~~";
}
}
package com.itchinajie.d6_abstact_temp;
public class Teacher extends People{
@Override
public String writeMain(){
return "我的爸爸也挺好的,让我站在这里别走,他去买点橘子~~~";
}
}
接口
认识接口
Java提供了一个关键字interface,用这个关键字我们可以定义出一个特殊的结构:接口。
package com.itchinajie.d7_interface;
public class Test {
public static void main(String[] args) {
//目标:认识接口
System.out.println(A.SCHOOL_NAME);
//A a = new A ();//注意:接口不能创建对象
D d = new D();
}
}
package com.itchinajie.d7_interface;
public interface A {
//成员变量(常量)
String SCHOOL_NAME = "黑马程序员";
//成员方法(抽象方法)
void test();
}
注意:接口不能创建对象;接口是用来被类实现(implements)的,实现接口的类称为实现类。
package com.itchinajie.d7_interface;
//实现类
public class D implements B,C {
@Override
public void testb1() {
}
@Override
public void testb2() {
}
@Override
public void testc1() {
}
@Override
public void testc2() {
}
}
package com.itchinajie.d7_interface;
public interface B {
void testb1();
void testb2();
}
package com.itchinajie.d7_interface;
public interface C {
void testc1();
void testc2();
}
一个类可以实现多个接口(接口可以理解成干爹),实现类实现多个接口,必须重写完全部接口的全部抽象方法,否则实现类需要定义成抽象类。
使用接口的好处
1、弥补了类单继承的不足,一个类同时可以实现多个接口。通过接口,我们可以让一个类有一个亲爹的同时,还可以找多个干爹去扩展自己的功能。
2、让程序可以面向接口编程,这样程序员就可以灵活方便的切换各种业务实现。一个类我们说可以实现多个接口,同样,一个接口也可以被多个类实现的。这样做的好处是我们的程序就可以面向接口编程了,这样我们程序员就可以很方便的灵活切换各种业务实现了。
package com.itchinajie.d8_interface2;
import com.itchinajie.d4_abstract.A;
public class Test {
public static void main(String[] args) {
//目标:搞清楚使用接口的好处
Driver s = new C();
s.drive();
Driver d = new B();
d.drive();
}
}
class B implements Driver{
@Override
public void drive() {
}
}
class C extends Student implements Driver , Singer{
@Override
public void drive() {
}
@Override
public void sing() {
}
}
class Student{
}
interface Driver{
void drive();
}
interface Singer{
void sing();
}
接口的应用案例:班级学生信息管理模块的开发
需求:
请设计一个班级学生的信息管理模块:学生的数据有:姓名、性别、成绩
功能1:要求打印出全班学生的信息;功能2:要求打印出全班学生的平均成绩。
注意!以上功能的业务实现是有多套方案的,比如:
第1套方案:能打印出班级全部学生的信息;能打印班级全部学生的平均分。
第2套方案:能打印出班级全部学生的信息(包含男女人数);能打印班级全部学生的平均分(要是去掉最高分、最低分)。
要求:系统可以支持灵活的切换这些实现方案。
package com.itchinajie.d9_interface_Demo;
//封装对象,姓名 性别 年龄
public class Student {
private String name;
private char sex;
private int age;
public Student() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Student(String name, char sex, int age) {
this.name = name;
this.sex = sex;
this.age = age;
}
}
//录入学生信息
package com.itchinajie.d9_interface_Demo;
import java.util.ArrayList;
public class ClassManager {
private ArrayList<Student> students = new ArrayList<>();
private StudentOperator studentOperator = new StudentOperatorImpl2();
public ClassManager(){
students.add(new Student("迪丽热巴",'女',99));
students.add(new Student("古力娜扎",'女',97));
students.add(new Student("马尔扎哈",'男',98));
students.add(new Student("卡尔扎巴",'男',99));
}
//打印全班全部学生的信息
public void printInfo(){
studentOperator.printAllInfo(students);
}
//打印全班全部学生的平均分
public void printScore(){
studentOperator.printAverageScore(students);
}
}
//创建接口类用来重写方法
package com.itchinajie.d9_interface_Demo;
import com.itchinajie.d4_abstract.A;
import java.util.ArrayList;
public interface StudentOperator {
void printAllInfo(ArrayList<Student> students);
void printAverageScore(ArrayList<Student> students);
}
//重写方法
package com.itchinajie.d9_interface_Demo;
import java.util.ArrayList;
public class StudentOperatorImpl1 implements StudentOperator{
@Override
public void printAllInfo(ArrayList<Student> students) {
System.out.println("----------全班全部学生信息如下-------------");
for (int i = 0; i < students.size(); i++) {
Student s = students.get(i);
System.out.println("姓名:" + s.getName() + ",性别:" + s.getSex() + ",成绩:" + s.getAge());
}
System.out.println("-----------------------------------");
}
@Override
public void printAverageScore(ArrayList<Student> students) {
double allScore = 0.0;
for (int i = 0; i < students.size(); i++) {
Student s = students.get(i);
allScore += s.getAge();
}
System.out.println("平均分:" + (allScore) / students.size());
}
}
//测试类
package com.itchinajie.d9_interface_Demo;
public class Test {
public static void main(String[] args) {
//目标:完成班级信息管理的案例
ClassManager clazz = new ClassManager();
clazz.printInfo();
clazz.printScore();
}
}
接口的其他细节JDK8开始,接口中新增的三种方法
1、默认方法:使用default修饰,使用实现类的对象调用。
2、静态方法:static修饰,必须用当前接口名调用
3、私有方法:private修饰,jdk9开始才有的,只能在接口内部被调用。
他们都会默认被public修饰。
package com.itchinajie.d10_interface_jdk8;
public class Test {
public static void main(String[] args) {
//目标:掌握接口新增的三种方法形式
B b = new B();
b.test1();
//b.test2();//访问私有方法报错
A.test3();
}
}
package com.itchinajie.d10_interface_jdk8;
public class B implements A{
}
package com.itchinajie.d10_interface_jdk8;
public interface A {
/*
* 1、默认方法:必须使用default修饰,默认会被public修饰
* 实例方法:对象的方法,必须是用实现类的对象来访问*/
public default void test1(){
System.out.println("===默认方法===");
test2();
}
/*
* 2、私有方法:必须使用private修饰(JDK9才开始支持)
* 实例方法:对象的方法.*/
private void test2(){
System.out.println("====私有方法===");
}
/*
* 3、静态方法:必须使用static修饰,默认会被public修饰
* */
static void test3(){
System.out.println("===静态方法===");
}
default void test6(){
}
}
新增的三种方法增强了接口的能力,更便于项目的扩展和维护。
接口的其他细节:接口的多继、使用接口的注意事项
接口其他注意事项(了解)
1、一个接口继承多个接口,如果多个接口中存在方法签名冲突,则此时不支持多继承。
2、一个类实现多个接口,如果多个接口中存在方法签名冲突,则此时不支持多实现。
3、一个类继承了父类,又同时实现了接口,父类中和接口中有同名的默认方法,实现类会优先用父类的。
4、一个类实现了多个接口,多个接口中存在同名的默认方法,可以不冲突,这个类重写该方法即可。
package com.itchinajie.d11_interface_attention;
public class Test {
public static void main(String[] args) {
//目标:理解接口的多继承
}
}
interface A{
void test1();
}
interface B{
void test2();
}
interface C{}
//接口是多继承的
interface D extends A,B,C{
}
class E implements D{
@Override
public void test1() {
}
@Override
public void test2() {
}
}
(本章图片均来自于黑马程序员视频)