目录
面向对象编程(中级部分)
IDE(集成开发环境)-IDEA
IDEA介绍
IDE(集成开发环境)-Eclipse
Eclipse介绍
IDEA的安装
IDEA的基本介绍和使用
创建一个java项目
IDEA使用技巧和经验
练习
IDEA常用快捷健
IDEA模板/自定义模板
包
看一个应用场景
包的三大作用
包基本语法
包的本质分析(原理)
快速入门
包的命名
命名规则
命名规范
常用的包
如何引入包
注意事项和使用细节
访问修饰符
基本介绍
4种访问修饰符的访问范围
使用的注意事项
面向对象编程三大特征
基本介绍
面向对象编程-封装
封装介绍
封装的理解和好处
封装的实现步骤(三步)
快速入门案例
练习题
面向对象编程-继承
为什么要继承
继承基本介绍和示意图
画出继承的示意图
继承的基本语法
快速入门案例
继承给编程带来的便利
继承的深入讨论/细节问题
继承的本质分析(重要)
案例
子类创建的内存布局编辑
练习题
super关键字
基本介绍
基本语法
super给编程带来的便利/细节
super和this的比较
方法重写/覆盖(override)
基本介绍
快速入门
注意事项和使用细节
练习题
面向对象编程-多态
先看一个问题
使用传统的方法来解决
传统的方法带来的问题是什么?如何解决?
多[多种]态[状态]的基本介绍
多态的具体体现
多态快速入门案例
多态注意事项和细节讨论
多态的向上转型
多态的向下转型
属性没有重写之说!属性的值看编译类型
instanceOf 比较操作符,用于判断对象的运行类型是否为XX类型或XX类型的子类型
练习题
java的动态绑定机制(非常重要)
多态的应用
1、多态数组
2、多态参数
面向对象编程(中级部分)
IDE(集成开发环境)-IDEA
IDEA介绍
1、IDEA全称InteIIiJ IDEA
2、在业界被公认为最好的Java开发工具
3、DEA是JetBrains公司的产品,总部位于捷克的首都布拉格
4、除了支持Java开发,还支持HTML,CSS,PHP,MySQL,Python等
IDE(集成开发环境)-Eclipse
Eclipse介绍
1、Eclipse是一个开放源代码的、基于Java的可扩展开发平台
2、最初是由IBM公司耗资3000万美金开发的下一代lDE开发环境
3、2001年11月贡献给开源社区
4、Eclipse是目前最优秀的Java开发ID之一
IDEA的安装
略
IDEA的基本介绍和使用
使用IDEA创建Java项目(project),看看IDEA是如何使用的,IDEA 是以项目的概念,来管理我们的java源码的
创建一个java项目
略
IDEA使用技巧和经验
设置字体
略
字符编码设置
略
练习
使用IDEA开发一个java项目,创建一个类MyTools,编写一个方法,可以完成对int数组冒泡排序的功能
public class ArrayTest {//编写一个main方法public static void main(String[] args) {MyTools mt = new MyTools();int[] arr = {10, -1, 8, 0, 34};mt.bubble(arr);//输出排序后的arrSystem.out.println("====排序后的arr====");for (int i = 0; i < arr.length; i++) {System.out.print(arr[i] + "\t");}}}//创建一个类MyTools,编写一个方法,可以完成对int数组冒泡排序的功能class MyTools {public void bubble(int[] arr) {//冒泡排序int temp = 0;for (int i = 0; i < arr.length - 1; i++) {//外层循环次数arr.length - 1for (int j = 0; j < arr.length - 1 - i; j++) {if (arr[j] > arr[j + 1]) {//交换temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}}}
运行结果
IDEA常用快捷健
1、删除当前行 ctrl+y
2、复制当前行 ctrl+d
3、补全代码alt +/
4、添加注释和取消注释ctrl +/[第一次是添加注释,第二次是取消注释]
5、导入该行需要的类 先配置auto import,然后使用alt+enter即可
6、快速格式化代码ctrl+shift+L
7、快速运行程序ctrl+shift+F10
8、生成构造器等alt + insert [提高开发效率]
9、查看一个类的层级关系ctrl +H [学习继承后,非常有用]
10、将光标放在一个方法上,输入ctrl + B,可以定位到方法[学继承后,非常有用]
11、自动的分配变量名,通过在后面加.var
12、还有很多其它的快捷键..
IDEA模板/自定义模板
模板可以高效的完成开发,提高速度
包
看一个应用场景
现在有两个程序员共同开发一个java项目,程序员xiaoming希望定义一个类取名 Dog,程序员xiaoqiang也想定义一个类也叫 Dog。两个程序员为此吵了起来,怎么办?->包
包的三大作用
1、区分相同名字的类
2、当类很多时,可以很好的管理类[看Java API文档]
3、控制访问范围
包基本语法
package com.hspedu;
说明:
1、package 关键字,表示打包
2、com.hspedu 表示包名
包的本质分析(原理)
实际上就是创建不同的文件夹来保存类文件,画出示意图。
快速入门
使用打包技术来解决上面的问题,不同包下Dog类
package com.use;import com.xiaoqiang.Dog;public class Test {public static void main(String[] args) {Dog dog = new Dog();System.out.println(dog);//com.xiaoqiang.Dog@4554617ccom.xiaoming.Dog dog1 = new com.xiaoming.Dog();System.out.println(dog1);//com.xiaoming.Dog@74a14482}}
包的命名
命名规则
只能包含数字、字母、下划线、小圆点..但不能用数字开头,不能是关键字或保留字demo.class.exec1 //错误class是关键字
demo.12a //错误 12a是数字开头
demo.ab12.oa //正确
命名规范
一般是小写字母+小圆点
一般是com.公司名.项目名.业务模块名
比如:com.hspedu.oa.model; com.hspedu.oa.controller;
举例:
com.sina.crm.user //用户模块
com.sina.crm.order //订单模块
com.sina.crm.utils //工具类
常用的包
一个包下,包含很多的类,java中常用的包有:
java.lang.* //lang包是基本包,默认引入,不需要再引入
java.util.* //util 包,系统提供的工具包,工具类,使用Scanner
.* //网络包,网络开发
java.awt.* //是做java的界面开发,GUI
如何引入包
语法:import包;
我们引入一个包的主要目的是要使用该包下的类
比如import java.util.Scanner; 就只是引入一个类Scanner
import java.util.*; //表示将 java.util包所有都引入
案例:使用系统提供 Arrays完成数组排序
package com.study;import java.util.Arrays;public class Import {public static void main(String[] args) {//使用系统提供的Arrays完成数组排序int[] arr = {-1, 20, 2, 13, 3};//比如对其进行排序//传统方法是,自己编写排序(冒泡)//系统是提供了相关的类,可以方便完成ArraysArrays.sort(arr);//输出排序结果for (int i = 0; i < arr.length; i++) {System.out.print(arr[i] + "\t");}}}
运行结果
注意事项和使用细节
1、package的作用是声明当前类所在的包,需要放在class的最上面,一个类中最多只有一句package
2、import指令位置放在package的下面,在类定义前面,可以有多句且没有顺序要求。
//package的作用是声明当前类所在的包,需要放在class的最上面,// 一个类中最多只有一句packagepackage com.study;//import指令位置放在package的下面,在类定义前面,可以有多句且没有顺序要求。import java.util.Arrays;import java.util.Scanner;//类定义public class PkgDetail {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);int[] arr = {0, -1, 1};Arrays.sort(args);}}
访问修饰符
基本介绍
java提供四种访问控制修饰符号控制方法和属性(成员变量)的访问权限(范围):
1、公开级别:用public修饰,对外公开
2、受保护级别:用protected修饰,对子类和同一个包中的类公开
3、默认级别:没有修饰符号,向同一个包的类公开
4、私有级别:用private修饰,只有类本身可以访问,不对外公开
4种访问修饰符的访问范围
使用的注意事项
1、修饰符可以用来修饰类中的属性,成员方法以及类
2、只有默认的和public才能修饰类!,并且遵循上述访问权限的特点
3、因为没有学习继承,因此关于在子类中的访问权限,讲完子类后,在回头讲解
4、成员方法的访问规则和属性完全一样
package com.modifier;public class A {//4个属性,分别使用不同的访问修饰符来修饰public int n1 = 100;protected int n2 = 200;int n3 = 300;private int n4 = 400;public void m1() {//在同一类中,可以访问public protected 默认 private 修饰属性和方法System.out.println("n1=" + n1 + " n2=" + n2 + " n3=" + n3 + " n4=" + n4);}protected void m2() {}void m3() {}private void m4() {}public void hi() {//在同一类中,可以访问public protected 默认 private 修饰属性和方法m1();m2();m3();m4();}}
package com.modifier;public class B {public void say() {A a = new A();//在同一个包下,可以访问public,protected和默认,不能访问privateSystem.out.println("n1=" + a.n1 + " n2=" + a.n2 + " n3=" + a.n3);a.m1();a.m2();a.m3();// a.m4();//错误}}
package com.modifier;public class Test {public static void main(String[] args) {A a = new A();a.m1();B b = new B();b.say();}}//只有 默认和public 可以修饰类class Tiger{}
package com.study;import com.modifier.A;public class Test {public static void main(String[] args) {A a = new A();//在不同包下,可以访问public修饰的属性或方法//但是不能访问protected,默认,private修饰的属性或方法System.out.println(a.n1);a.m1();// a.m2();//错误// a.m3();//错误// a.m4();//错误}}
面向对象编程三大特征
基本介绍
面向对象编程有三大特征:封装、继承、多态
面向对象编程-封装
封装介绍
封装(encapsulation)就是把抽象出的数据[属性]和对数据的操作[方法]封装在一起,数据被保护在内部,程序的其它部分只有通过被授权的操作[方法],才能对数据进行操作。
封装的理解和好处
1、隐藏实现细节:方法(连接数据库) <--调用(传入参数...)
2、可以对数据进行验证,保证安全合理
Person {name, age}
Person p = new Person();
p.name = "jack";
p.age = 1200;
封装的实现步骤(三步)
1、将属性进行私有化private [不能直接修改属性]
2、提供一个公共的(public)set方法,用于对属性判断并赋值
public void setXxx(类型 参数名){//Xxx表示某个属性//加入数据验证的业务逻辑属性 = 参数名;}
3、提供一个公共的(public)get方法,用于获取属性的值
public 数据类型 getXxx(){//权限判断,Xxx某个属性return xx;}
快速入门案例
看一个案例
那么在java中如何实现这种类似的控制呢?
看一个小程序,不能随便查看人的年龄,工资等隐私,并对设置的年龄进行合理的验证。年龄合理就设置,否则给默认年龄,必须在1-1龄,工资不能直接查看,name的长度在2-6之间
package com.encap;public class Encapsulation {public static void main(String[] args) {Person person = new Person();person.setName("Tom");person.setAge(30);person.setSalary(30000);System.out.println(person.toString());System.out.println(person.getSalary());//使用构造器指定属性Person smith = new Person("smith", 2000, 60000);System.out.println("========smith的信息========");System.out.println(smith.toString());}}//不能随便查看人的年龄,工资等隐私,并对设置的年龄进行合理的验证。//年龄合理就设置,否则给默认年龄,必须在1-1龄,//工资不能直接查看,name的长度在2-6之间class Person {public String name;//名字 公开private int age;//年龄 私有化private double salary;//工资 私有化public Person() {}public Person(String name, int age, double salary) {// this.name = name;// this.age = age;// this.salary = salary;//可以将set方法写在构造器中,这样仍然可以验证setName(name);setAge(age);setSalary(salary);}public String getName() {return name;}public void setName(String name) {//加入对数据的校验,相当于增加了业务逻辑if (name.length() >= 2 && name.length() <= 6) {this.name = name;} else {System.out.println("名字长度不对,需要(2-6)个字符,默认名字");this.name = "无名氏";}}public int getAge() {return age;}public void setAge(int age) {//判断if (age >= 1 && age <= 120) {this.age = age;} else {System.out.println("你设置的年龄不对,年龄需要在1-120,给默认年龄18");this.age = 18;//给一个默认的年龄}}public double getSalary() {//这里可以增加对当前对象的权限判断return salary;}public void setSalary(double salary) {this.salary = salary;}//写一个方法,返回属性信息@Overridepublic String toString() {return "Person{" +"name='" + name + '\'' +", age=" + age +", salary=" + salary +'}';}}
运行结果
练习题
创建程序,在其中定义两个类:Account和AccountTest类体会Java的封装性。
1、Account类要求具有属性:姓名(长度为2位3位或4位)、余额(必须>20)、密码(必须是六位),如果不满足,则给出提示信息,并给默认值
2、通过setXxx的方法给Account的属性赋值。
3、在AccountTest中测试
提示知识点:
String name = "";
int len = name.length(); //字符串的长度
package com.encap;//创建程序,在其中定义两个类:Account和AccountTest类体会Java的封装性。//1、Account类要求具有属性:姓名(长度为2位3位或4位)、余额(必须>20)、//密码(必须是六位),如果不满足,则给出提示信息,并给默认值//2、通过setXxx的方法给Account的属性赋值。//3、在AccountTest中测试public class Account {//为了封装,将3个属性设置为privateprivate String name;private double balance;private String pwd;//提供两个构造器public Account() {}public Account(String name, double balance, String pwd) {this.setName(name);this.setBalance(balance);this.setPwd(pwd);}public String getName() {return name;}//public void setName(String name) {if (name.length() >= 2 && name.length() <= 4) {this.name = name;} else {System.out.println("姓名(长度为2位3位或4位),默认为‘无名氏’");this.name = "无名氏";}}public double getBalance() {return balance;}// 余额(必须>20)public void setBalance(double balance) {if (balance > 20) {this.balance = balance;} else {System.out.println("余额(必须>20),默认为0");}}public String getPwd() {return pwd;}// 密码(必须是六位)public void setPwd(String pwd) {if (pwd.length() == 6) {this.pwd = pwd;} else {System.out.println("密码(必须是六位),默认密码123456");this.pwd = "123456";}}public void showInfo() {System.out.println("Account{" +"name='" + name + '\'' +", balance=" + balance +", pwd='" + pwd + '\'' +'}');}}
package com.encap;public class TestAccount {public static void main(String[] args) {//创建AccountAccount account = new Account();account.setName("jack21313");account.setBalance(6000);account.setPwd("654321");account.showInfo();}}
运行结果
面向对象编程-继承
为什么要继承
一个小问题,看程序,提出代码复用的问题
我们编写了两个类,一个是Pupil类(小学生),一个是Graduate(研究生)。
问题:两个类的属性和方法有很多是相同的,怎么办?
解决方案:->继承(代码复用性~~~)
package com.extend;//小学生->模拟小学生考试的情况public class Pupil {public String name;public int age;private double score;//成绩public void setScore(double score) {this.score = score;}public void testing() {System.out.println("小学生 " + name + " 正在考小学数学。。");}public void showInfo() {System.out.println("小学生 " + name + " 年龄" + age + " 成绩" + score);}}
package com.extend;//大学生->模拟大学生考试的情况public class Graduate {public String name;public int age;private double score;//成绩public void setScore(double score) {this.score = score;}public void testing() {//和Pupil不一样System.out.println("大学生 " + name + " 正在考大学高数。。");}public void showInfo() {System.out.println("大学生 " + name + " 年龄" + age + " 成绩" + score);}}
package com.extend;public class Extends {public static void main(String[] args) {Pupil pupil = new Pupil();pupil.name = "小明";pupil.age = 12;pupil.testing();pupil.setScore(60);pupil.showInfo();System.out.println("===========================");Graduate graduate = new Graduate();graduate.name = "蔡徐坤";graduate.age = 21;graduate.testing();graduate.setScore(99);graduate.showInfo();}}
运行结果
继承基本介绍和示意图
继承可以解决代码复用,让我们的编程更加靠近人类思维。当多个类存在相同的属性(变量)和方法时,可以从这些类中抽象出父类,在父类中定义这些相同的属性和方法,所有的子类不需要重新定义这柴属性和方法,只需要通过extends来声明继承父类即可。
画出继承的示意图
继承的基本语法
class子类extends 父类{}
1、子类就会自动拥有父类定义的属性和方法
2、父类又叫超类,基类。
3、子类又叫派生类。
快速入门案例
对Extends.java改进,使用继承的方法
package com.extend;//父类,是Pupil和Graduate的父类public class Student {//共有属性public String name;public int age;private double score;//成绩//共有的方法public void setScore(double score) {this.score = score;}public void showInfo() {System.out.println("学生名 " + name + " 年龄" + age + " 成绩" + score);}}
package com.extend;//小学生->模拟小学生考试的情况public class Pupil extends Student {public void testing() {System.out.println("小学生 " + name + " 正在考小学数学...");}}
package com.extend;//大学生->模拟大学生考试的情况public class Graduate extends Student {public void testing() {//和Pupil不一样System.out.println("大学生 " + name + " 正在考大学高数...");}}
package com.extend;public class Extends {public static void main(String[] args) {Pupil pupil = new Pupil();pupil.name = "小明";pupil.age = 12;pupil.testing();pupil.setScore(60);pupil.showInfo();System.out.println("===========================");Graduate graduate = new Graduate();graduate.name = "蔡徐坤";graduate.age = 21;graduate.testing();graduate.setScore(99);graduate.showInfo();}}
运行结果
继承给编程带来的便利
1、代码的复用性提高了
2、代码的扩展性和维护性提高了
继承的深入讨论/细节问题
1、子类继承了所有的属性和方法,非私有的属性和方法可以在子类直接访问,但是私有属性和方法不能在子类直接访问,要通过父类提供公共的方法去访问
package com.extend;public class Base {//父类//4个属性public int n1 = 100;protected int n2 = 200;int n3 = 300;private int n4 = 400;public Base() {//无参构造器System.out.println("Base()...");}//父类提供一个public的方法,返回了n4public int getN4() {return n4;}public void test100() {System.out.println("test100");}protected void test200() {System.out.println("test200");}void test300() {System.out.println("test300");}private void test400() {System.out.println("test400");}//callpublic void callTest400() {test400();}}
package com.extend;public class Sub extends Base {//子类public Sub() {//构造器System.out.println("Sub()...");}public void sayOk() {//子类方法//非私有的属性和方法可以在子类直接访问//但是私有属性和方法不能在子类直接访问System.out.println(n1 + " " + n2 + " " + n3);test100();test200();test300();// test400();//错误//要通过父类提供公共的方法去访问System.out.println("n4=" + getN4());callTest400();}}
package com.extend;public class ExtendsDetail {public static void main(String[] args) {Sub sub = new Sub();sub.sayOk();}}
运行结果
2、子类必须调用父类的构造器,完成父类的初始化
3、当创建子类对象时,不管使用子类的哪个构造器,默认情况下总会去调用父类的无参构造器,如果父类没有提供无参构造器,则必须在子类的构造器中用super 去指定使用父类的哪个构造器完成对父类的初始化工作,否则,编译不会通过[举例说明]
4、如果希望指定去调用父类的某个构造器,则显式的调用一下:super(参数列表)
5、super 在使用时,必须放在构造器第一行(super 只能在构造器中使用)
6、super() 和 this() 都只能放在构造器第一行,因此这两个方法不能共存在一个构造器
7、java 所有类都是 Object 类的子类,Object 是所有类的基类
8、父类构造器的调用不限于直接父类!将一直往上追溯直到 Object 类(顶级父类)
9、子类最多只能继承一个父类(指直接继承),即 java 中是单继承机制
思考:如何让 A 类继承 B 类和 C 类? 【A 继承 B, B 继承 C】
10、不能滥用继承,子类和父类之间必须满足 is-a 的逻辑关系
Person is a Music?
Person Music
Music extends Person //不合理
Animal
Cat extents Animal //合理
package com.extend;public class Base extends ToBase{//父类//4个属性public int n1 = 100;protected int n2 = 200;int n3 = 300;private int n4 = 400;public Base() {//无参构造器System.out.println("父类Base()构造器被调用...");}public Base(String name, int age) {//有参构造器//默认super();System.out.println("父类Base(String name, int age)构造器被调用...");}public Base(String name) {//有参构造器System.out.println("父类Base(String name)构造器被调用...");}//父类提供一个public的方法,返回了n4public int getN4() {return n4;}public void test100() {System.out.println("test100");}protected void test200() {System.out.println("test200");}void test300() {System.out.println("test300");}private void test400() {System.out.println("test400");}//callpublic void callTest400() {test400();}}
package com.extend;public class Sub extends Base {//子类public Sub(String name, int age) {//1.要调用父类的无参构造器,如下或者 什么都不写,默认就是调用super()// super();//父类的无参构造器//2.要调用父类的Base(String name)构造器// super("甲柒");//3.要调用父类的Base(String name, int age)构造器super("甲柒", 21);//细节:super 在使用时,必须放在构造器第一行(super 只能在构造器中使用)//细节:super() 和 this() 都只能放在构造器第一行,因此这两个方法不能共存在一个构造器System.out.println("子类Sub(String name, int age)构造器被调用...");}public Sub() {//无参构造器// super();//默认调用父类的无参构造器super("smith", 10);System.out.println("子类Sub()构造器被调用...");}//当创建子类对象时,不管使用子类的哪个构造器,默认情况下总会去调用父类的无参构造器public Sub(String name) {super("tom", 30);//do nothing...System.out.println("子类Sub(String name)构造器被调用...");}public void sayOk() {//子类方法//非私有的属性和方法可以在子类直接访问//但是私有属性和方法不能在子类直接访问System.out.println(n1 + " " + n2 + " " + n3);test100();test200();test300();// test400();//错误//要通过父类提供公共的方法去访问System.out.println("n4=" + getN4());callTest400();}}
package com.extend;public class ExtendsDetail {public static void main(String[] args) {// System.out.println("========第1个对象=========");// Sub sub = new Sub();//创建了子类对象sub// System.out.println("========第2个对象=========");// Sub sub2 = new Sub("jack");//创建了子类对象sub2// sub.sayOk();System.out.println("========第3个对象=========");Sub sub3 = new Sub("king", 10);//创建了子类对象sub3}}
package com.extend;public class ToBase {public ToBase() {//super(); Object的无参构造器System.out.println("构造器ToBase()被调用...");}}
继承的本质分析(重要)
案例
看一个案例来分析当子类继承父类,创建子类对象时,内存中到底发生了什么?
提示:当子类对象创建好后,建立查找的关系
package com.extend;//继承的本质public class ExtendsTheory {public static void main(String[] args) {Son son = new Son();//内存的布局//?->注意,要按照查找关系来返回信息//(1)首先看子类是否有该属性//(2)如果子类有这个属性,并且可以访问,则返回信息//(3)如果子类没有这个属性,就看父类有没有这个属性(如果父类有这个属性,并且可以访问,则返回信息)//(4)如果父类没有就按照(3)的规则,继续找上级父类,直到Object...System.out.println(son.name);//返回的就是大头儿子// System.out.println(son.age);//返回的就是39System.out.println(son.getAge());//返回的就是39System.out.println(son.hobby);//返回的就是旅游}}class GrandPa {//爷类String name = "大头爷爷";String hobby = "旅游";}class Father extends GrandPa {//父类String name = "大头爸爸";private int age = 39;public int getAge() {return age;}}class Son extends Father {//子类String name = "大头儿子";}
运行结果
子类创建的内存布局
练习题
1、案例1
package com.extend;public class ExtendsExercise {public static void main(String[] args) {B b = new B();}}class A {A() {System.out.println("a");}A(String name) {System.out.println("a name");}}class B extends A {B() {this("abc");System.out.println("b");}B(String name) {System.out.println("b name");}}
运行结果
2、案例2
package com.extend;public class ExtendsExercise {public static void main(String[] args) {C c = new C();}}class A {//A类public A() {System.out.println("我是A类");}}class B extends A {//B类,继承A类public B() {System.out.println("我是B类的无参构造");}public B(String name) {System.out.println(name + "我是B类的有参构造");}}class C extends B {//C类,继承B类public C() {this("hello");System.out.println("我是C类的无参构造");}public C(String name) {super("hahah");System.out.println("我是C类的有参构造");}}
运行结果
3、案例3
编写 Computer 类,包含 CPU、内存、硬盘等属性,
getDetails 方法用于返回 Computer 的详细信息
编写 PC 子类,继承 Computer 类,添加特有属性【品牌 brand】
编写 NotePad 子类,继承 Computer 类,添加特有属性【color】
编写 Test 类,在 main 方法中创建 PC 和 NotePad 对象,分别给对象中特有的属性赋值,
以及从 Computer 类继承的 属性赋值,并使用方法并打印输出信息
package com.extend;//编写 Computer 类,包含 CPU、内存、硬盘等属性,//getDetails 方法用于返回 Computer 的详细信息public class Computer {private String cpu;private int memory;private int disk;public Computer(String cpu, int memory, int disk) {this.cpu = cpu;this.memory = memory;this.disk = disk;}//返回Computerpublic String getDetails() {return "cpu=" + cpu + " memory=" + memory + " disk=" + disk;}public String getCpu() {return cpu;}public void setCpu(String cpu) {this.cpu = cpu;}public int getMemory() {return memory;}public void setMemory(int memory) {this.memory = memory;}public int getDisk() {return disk;}public void setDisk(int disk) {this.disk = disk;}}
package com.extend;//编写 PC 子类,继承 Computer 类,添加特有属性【品牌 brand】public class PC extends Computer {private String brand;//这里IDEA 根据继承的规则,自动把构造器的调用写好//这里也体现:继承设计的基本思想,父类的构造器完成父类属性初始化//子类的构造器完成子类属性初始化public PC(String cpu, int memory, int disk, String brand) {super(cpu, memory, disk);this.brand = brand;}public String getBrand() {return brand;}public void setBrand(String brand) {this.brand = brand;}public String printInfo() {// System.out.println(getCpu() + getMemory() + getDisk());//调用父类的getDetails方法,得到相关属性信息...return getDetails() + " brand=" + brand;}}
package com.extend;//编写 NotePad 子类,继承 Computer 类,添加特有属性【color】public class NotePad extends PC {private String color;public NotePad(String cpu, int memory, int disk, String brand, String color) {super(cpu, memory, disk, brand);this.color = color;}public String getColor() {return color;}public void setColor(String color) {this.color = color;}public void ShowInfo() {System.out.println("PC信息");System.out.println(printInfo() + " color=" + color);}}
package com.extend;public class ExtendsExercise {public static void main(String[] args) {NotePad notePad1 = new NotePad("intel", 32, 512, "hp", "黑色");notePad1.ShowInfo();NotePad notePad2 = new NotePad("AMD", 16, 512, "lenovo", "银色");notePad2.ShowInfo();}}//编写 Computer 类,包含 CPU、内存、硬盘等属性,//getDetails 方法用于返回 Computer 的详细信息//编写 PC 子类,继承 Computer 类,添加特有属性【品牌 brand】//编写 NotePad 子类,继承 Computer 类,添加特有属性【color】//编写 Test 类,在 main 方法中创建 PC 和 NotePad 对象,分别给对象中特有的属性赋值,//以及从 Computer 类继承的 属性赋值,并使用方法并打印输出信息
运行结果
super关键字
基本介绍
super代表父类的引用,用于访问父类的属性、方法、构造器
基本语法
1、访问父类的属性,但不能访问父类的private属性[案例]
super.属性名;
2、访问父类的方法,不能访问父类的private方法
super.方法名(参数列表);
3、访问父类的构造器
super(参数列表);只能放在构造器的第一句,只能出现一句!
package com.super_;public class A {//4个属性public int n1 = 100;protected int n2 = 200;int n3 = 300;private int n4 = 400;public A() {}public A(String name) {}public A(String name, int age) {}public void test100() {}protected void test200() {}void test300() {}private void test400() {}}
package com.super_;public class B extends A {//访问父类的构造器//super(参数列表);只能放在构造器的第一句,只能出现一句!public B() {// super();// super("jack",18);super("tom");}//访问父类的属性,但不能访问父类的private属性[案例]//super.属性名;public void hi() {System.out.println(super.n1 + " " + super.n2 + " " + super.n3);}//访问父类的方法,不能访问父类的private方法//super.方法名(参数列表);public void ok() {super.test100();super.test200();super.test300();// super.test400();//不能访问父类private方法}}
super给编程带来的便利/细节
1、调用父类的构造器的好处
分工明确,父类属性由父类初始化,子类属性由子类初始化
2、当子类中有和父类中的成员(属性和方法)重名时,为了访问父类的成员,必须通过super。如果没有重名,使用super、this、直接访问是一样的效果!
package com.super_;public class A {//4个属性public int n1 = 100;protected int n2 = 200;int n3 = 300;private int n4 = 400;public A() {}public A(String name) {}public A(String name, int age) {}public void test100() {}protected void test200() {}void test300() {}private void test400() {}public void cal() {System.out.println("A类的cal()方法...");}}
package com.super_;public class B extends A {public int n1 = 888;//访问父类的构造器//super(参数列表);只能放在构造器的第一句,只能出现一句!public B() {// super();// super("jack",18);super("tom");}//访问父类的属性,但不能访问父类的private属性[案例]//super.属性名;public void hi() {System.out.println(super.n1 + " " + super.n2 + " " + super.n3);}//访问父类的方法,不能访问父类的private方法//super.方法名(参数列表);public void ok() {super.test100();super.test200();super.test300();// super.test400();//不能访问父类private方法}public void cal() {System.out.println("B类的cal()方法...");}public void sum() {System.out.println("B类的sum()方法...");//希望调用父类-A的cal方法//这时,因为子类B没有cal方法,因此可以使用下面三种方式//找cal方法时,顺序是,//(1)先找本类,如果有,则调用,//(2)如果没有,则找父类(如果有,并可以调用,则调用)//(3)如果父类没有,则继续找父类的父类,整个规则是一样的,直到Object类//提示:如果查找方法的过程中,找到了,但是不能访问,则报错,cannot access//如果查找方法的过程中,没有找到,则提示方法不存在// cal();// this.cal();//等价cal();super.cal();//找cal方法的顺序是(跳过本类的cal)直接查找父类,其他规则一样//演示访问属性的规则//n1 和 this.n1 查找的规则是//(1)先找本类,如果有,则调用//(2)如果没有,则找父类(如果有,并可以调用,则调用)//(3)如果父类没有,则继续找父类的父类,整个规则是一样的,直到Object类//提示:如果查找属性的过程中,找到了,但是不能访问,则报错,cannot access//如果查找属性的过程中,没有找到,则提示属性不存在System.out.println(n1);System.out.println(this.n1);//找n1 (super.n1) 的顺序是直接查找父类属性,其他规则一样System.out.println(super.n1);}}
package com.super_;public class Super {public static void main(String[] args) {B b = new B();b.sum();}}
3、super的访问不限于直接父类,如果爷爷类和本类中有同名的成员,也可以使用super去访问爷爷类的成员;如果多个基类(上级类)中都有同名的成员,使用super访问遵循就近原则。A->B->C,当然也需要遵守访问权限的相关规则
super和this的比较
方法重写/覆盖(override)
基本介绍
简单的说:方法覆盖(重写)就是子类有一个方法,和父类的某个方法的名称、返回类型、参数一样,那么我们就说子类的这个方法覆盖了父类的方法
快速入门
package com.override;public class Animal {public void cry() {System.out.println("动物发出声音~~~");}}
package com.override;public class Dog extends Animal {//解读//1.因为Dog是Animal子类//2.Dog的cry方法和Animal的cry定义形式一样(名称、返回类型、参数)//3.这时我们就说Dog的cry方法,重写了Animal的cry方法public void cry() {System.out.println("小狗汪汪叫~~~");}}
package com.override;public class Override {public static void main(String[] args) {//演示方法重写的情况Dog dog = new Dog();dog.cry();}}
运行结果
注意事项和使用细节
方法重写也叫方法覆盖,需要满足下面的条件
1、子类方法的形参列表,方法名称,要和父类方法的形参列表,方法名称完全一样。
2、子类方法的返回类型和父类方法返回类型一样,或者是父类返回类型的子类
比如:父类返回类型是Object,子类方法返回类型是String
public class Animal {public Object run(){return null;}}
public class Dog extends Animal {public String run(){return null;}}
3、子类方法不能缩小父类方法的访问权限(可以扩大)
public > protected > 默认 > private
练习题
1、方法的重写和重载的比较
2、
1) 编写一个 Person 类,包括属性/private(name、age),构造器、方法 say(返回自我介绍的字符串)。
2) 编写一个 Student 类,继承 Person 类,增加 id、score 属性/private,以及构造器,定义 say 方法(返回自我介绍的信息)。
3) 在 main 中,分别创建 Person 和 Student 对象,调用 say 方法输出自我介绍
package com.override;//编写一个 Person 类,包括属性/private(name、age),构造器、方法 say(返回自我介绍的字符串)。public class Person {private String name;private int age;public Person(String name, int age) {this.name = name;this.age = age;}public String say() {return "name=" + name + " age=" + age;}}
package com.override;// 编写一个 Student 类,继承 Person 类,增加 id、score 属性/private,以及构造器,定义 say 方法(返回自我介绍的信息)。public class Student extends Person {private int id;private double score;public Student(String name, int age, int id, double score) {super(name, age);//这里会调用父类构造器this.id = id;this.score = score;}//saypublic String say() {//这里体现super的一个好处,代码复用return super.say() + " id=" + id + " score=" + score;}public int getId() {return id;}public void setId(int id) {this.id = id;}public double getScore() {return score;}public void setScore(double score) {this.score = score;}}
package com.override;//在 main 中,分别创建 Person 和 Student 对象,调用 say 方法输出自我介绍public class OverrideExercise {public static void main(String[] args) {Person jack = new Person("jack", 18);System.out.println(jack.say());Student tom = new Student("tom", 20, 123456, 99.9);System.out.println(tom.say());}}
运行结果
面向对象编程-多态
先看一个问题
请编写一个程序,Master类中有一个 feed(喂食)方法,可以完成主人给动物喂食物的信息。
使用传统的方法来解决
package com.poly;public class Food {private String name;public Food(String name) {this.name = name;}public String getName() {return name;}public void setName(String name) {this.name = name;}}
package com.poly;public class Fish extends Food{public Fish(String name) {super(name);}}
package com.poly;public class Bone extends Food{public Bone(String name) {super(name);}}
package com.poly;public class Animal {private String name;public Animal(String name) {this.name = name;}public String getName() {return name;}public void setName(String name) {this.name = name;}}
package com.poly;public class Cat extends Animal{public Cat(String name) {super(name);}}
package com.poly;public class Dog extends Animal{public Dog(String name) {super(name);}}
package com.poly;public class Master {private String name;public Master(String name) {this.name = name;}public String getName() {return name;}public void setName(String name) {this.name = name;}//主人给小狗喂食public void feed(Dog dog, Bone bone) {System.out.println("主人 " + name + " 给 " + dog.getName() + " 吃 " + bone.getName());}//主人给小猫喂黄花鱼public void feed(Cat cat, Fish fish) {System.out.println("主人 " + name + " 给 " + cat.getName() + " 吃 " + fish.getName());}//如果动物很多,食物很多//->feed方法很多,不利于管理和维护}
package com.poly;public class Poly {public static void main(String[] args) {Master tom = new Master("汤姆");Dog dog = new Dog("大黄");Bone bone = new Bone("大骨头");tom.feed(dog, bone);Cat cat = new Cat("小猫");Fish fish = new Fish("黄花鱼");System.out.println("=================");tom.feed(cat, fish);}}
传统的方法带来的问题是什么?如何解决?
问题是:代码的复用性不高,而且不利于代码维护
解决方案:引出 多态
多[多种]态[状态]的基本介绍
方法或对象具有多种形态,是面向对象的第三大特征,多态是建立在封装和继承基础之上的
多态的具体体现
1、方法的多态
重写和重载就体现多态
package com.poly;public class PolyMethod {public static void main(String[] args) {//方法重载体现多态A a = new A();//这里传入不同的参数,就会调用不同sum方法,就体现多态System.out.println(a.sum(10, 20));System.out.println(a.sum(10, 20, 30));//方法重写体现多态B b = new B();a.say();b.say();}}class B {//父类public void say() {System.out.println("B say() 方法被调用...");}}class A extends B {//子类public int sum(int n1, int n2) {//和下面sum构成重载return n1 + n2;}public int sum(int n1, int n2, int n3) {return n1 + n2 + n3;}public void say() {System.out.println("A say() 方法被调用...");}}
2、对象的多态
重要的几句话
(1)一个对象的编译类型和运行类型可以不一致
(2)编译类型在定义对象时,就确定了,不能改变
(3)运行类型是可以变化的
(4)编译类型看定义时=号的左边,运行类型看=号的右边
package com.objectpoly;public class Animal {public void cry(){System.out.println("Animal cry() 动物在叫...");}}
package com.objectpoly;public class Cat extends Animal{@Overridepublic void cry() {System.out.println("Cat cry() 小猫喵喵叫...");}}
package com.objectpoly;public class Dog extends Animal{@Overridepublic void cry() {System.out.println("Dog cry() 小狗汪汪叫...");}}
package com.objectpoly;public class PolyObject {public static void main(String[] args) {//体验对象多态特点//animal 编译类型就是 Animal,运行类型DogAnimal animal = new Dog();//因为运行时,这时就执行到该行时,animal运行类型是Dog,所以cry就是Dog的cryanimal.cry();//小狗汪汪叫//animal 编译类型 Animal,运行类型就是Catanimal = new Cat();animal.cry();//小猫喵喵叫}}
运行结果
多态快速入门案例
package com.poly;public class Animal {private String name;public Animal(String name) {this.name = name;}public String getName() {return name;}public void setName(String name) {this.name = name;}}
package com.poly;public class Cat extends Animal{public Cat(String name) {super(name);}}
package com.poly;public class Dog extends Animal{public Dog(String name) {super(name);}}
package com.poly;public class Pig extends Animal {public Pig(String name) {super(name);}}
package com.poly;public class Food {private String name;public Food(String name) {this.name = name;}public String getName() {return name;}public void setName(String name) {this.name = name;}}
package com.poly;public class Bone extends Food {public Bone(String name) {super(name);}}
package com.poly;public class Fish extends Food {public Fish(String name) {super(name);}}
package com.poly;public class Rice extends Food {public Rice(String name) {super(name);}}
package com.poly;public class Master {private String name;public Master(String name) {this.name = name;}public String getName() {return name;}public void setName(String name) {this.name = name;}//使用多态机制,可以统一管理主人喂食的问题//animal 编译类型是Animal,可以指向(接收) Animal子类对象//food 编译类型是Food,可以指向(接收) Food子类对象public void feed(Animal animal,Food food){System.out.println("主人 " + name + " 给 " + animal.getName() + " 吃 " + food.getName());}// //主人给小狗喂食// public void feed(Dog dog, Bone bone) {// System.out.println("主人 " + name + " 给 " + dog.getName() + " 吃 " + bone.getName());// }//// //主人给小猫喂黄花鱼// public void feed(Cat cat, Fish fish) {// System.out.println("主人 " + name + " 给 " + cat.getName() + " 吃 " + fish.getName());// }//// //如果动物很多,食物很多// //->feed方法很多,不利于管理和维护}
package com.poly;public class Poly {public static void main(String[] args) {Master tom = new Master("汤姆");Dog dog = new Dog("大黄~");Bone bone = new Bone("大骨头~");tom.feed(dog, bone);Cat cat = new Cat("小猫~");Fish fish = new Fish("黄花鱼~");System.out.println("=================");tom.feed(cat, fish);//添加给小猪喂米饭Pig pig = new Pig("小香猪~");Rice rice = new Rice("米饭~");System.out.println("=================");tom.feed(pig, rice);}}
运行结果
多态注意事项和细节讨论
多态的前提是:两个对象(类)存在继承关系
多态的向上转型
1、本质:父类的引用指向了子类的对象
2、语法:父类类型引用名 = new 子类类型();
3、特点:编译类型看左边,运行类型看右边。
可以调用父类中的所有成员(需遵守访问权限),
不能调用子类中特有成员;
最终运行效果看子类的具体实现!
package com.polydetail;public class Animal {String name = "动物";int age = 10;public void sleep() {System.out.println("睡");}public void run() {System.out.println("跑");}public void eat() {System.out.println("吃");}public void show() {System.out.println("hello,world");}}
package com.polydetail;public class Cat extends Animal {public void eat() {//方法重写System.out.println("猫吃鱼");}public void catchMouse() {//Cat特有方法System.out.println("猫抓老鼠");}}
package com.polydetail;public class PolyDetail {public static void main(String[] args) {//向上转型:父类的引用指向了子类的对象//语法:父类类型引用名 = new 子类类型();Animal animal = new Cat();Object obj = new Cat();//Object 也是 Cat的父类//向上转型调用方法的规则如下//可以调用父类中的所有成员(需遵守访问权限)//但是不能调用子类中特有成员//因为在编译阶段,能调用哪些成员,是由编译类型来决定的// animal.catchMouse;//错误//最终运行效果看子类的具体实现,即调用方法时,按照从子类(运行类型)开始查找方法//然后调用,规则跟之前的方法调用规则一致animal.eat();//猫吃鱼animal.run();//跑animal.show();//hello,worldanimal.sleep();//睡System.out.println("ok~~");}}
运行结果
多态的向下转型
1、语法:子类类型引用名 = (子类类型)父类引用;
2、只能强转父类的引用,不能强转父类的对象
3、要求父类的引用必须指向的是当前目标类型的对象
4、当向下转型后,可以调用子类类型中所有的成员
package com.polydetail;public class Animal {String name = "动物";int age = 10;public void sleep() {System.out.println("睡");}public void run() {System.out.println("跑");}public void eat() {System.out.println("吃");}public void show() {System.out.println("hello,world");}}
package com.polydetail;public class Cat extends Animal {public void eat() {//方法重写System.out.println("猫吃鱼");}public void catchMouse() {//Cat特有方法System.out.println("猫抓老鼠");}}
package com.polydetail;public class Dog extends Animal{//Dog 是 Animal的子类}
package com.polydetail;public class PolyDetail {public static void main(String[] args) {//向上转型:父类的引用指向了子类的对象//语法:父类类型引用名 = new 子类类型();Animal animal = new Cat();Object obj = new Cat();//Object 也是 Cat的父类//向上转型调用方法的规则如下//(1)可以调用父类中的所有成员(需遵守访问权限)//(2)但是不能调用子类中特有成员//(3)因为在编译阶段,能调用哪些成员,是由编译类型来决定的// animal.catchMouse;//错误//(4)最终运行效果看子类的具体实现,即调用方法时,按照从子类(运行类型)开始查找方法//然后调用,规则跟之前的方法调用规则一致animal.eat();//猫吃鱼animal.run();//跑animal.show();//hello,worldanimal.sleep();//睡//希望可以调用Cat的 catchMouse方法//多态的向下转型//(1)语法:子类类型引用名 = (子类类型)父类引用;//cat 的编译类型 Cat,运行类型 CatCat cat = (Cat) animal;cat.catchMouse();//(2)要求父类的引用必须指向的是当前目标类型的对象// Dog dog = (Dog) animal;//错误System.out.println("ok~~");}}
运行结果
属性没有重写之说!属性的值看编译类型
package com.polydetail;public class PolyDetail02 {public static void main(String[] args) {//属性没有重写之说!属性的值看编译类型Base base = new Sub();//向上转型System.out.println(base.count);//看编译类型 10Sub sub = new Sub();System.out.println(sub.count);//20}}class Base {//父类int count = 10;//属性}class Sub extends Base {//子类int count = 20;//属性}
运行结果
instanceOf 比较操作符,用于判断对象的运行类型是否为XX类型或XX类型的子类型
package com.polydetail;public class PolyDetail03 {public static void main(String[] args) {BB bb = new BB();System.out.println(bb instanceof BB);//trueSystem.out.println(bb instanceof AA);//true//aa 编译类型 AA,运行类型 BBAA aa = new BB();System.out.println(aa instanceof AA);//trueSystem.out.println(aa instanceof BB);//trueObject obj = new Object();System.out.println(obj instanceof AA);//falseString str = "hello";// System.out.println(str instanceof AA);//报错System.out.println(str instanceof Object);//true}}class AA {//父类}class BB extends AA {//子类}
运行结果
练习题
1、请说出下面的每条语言,哪些是正确的,哪些是错误的,为什么?
2、
package com.polydetail;public class PolyExercise {//主类public static void main(String[] args) {Sub s = new Sub();System.out.println(s.count);//20s.display();//20Base b = s;System.out.println(b == s);//trueSystem.out.println(b.count);//10b.display();//20}}class Base {//父类int count = 10;public void display() {System.out.println(this.count);}}class Sub extends Base {//子类int count = 20;public void display() {System.out.println(this.count);}}
运行结果
java的动态绑定机制(非常重要)
Java重要特性:动态绑定机制
java的动态绑定机制
1、当调用对象方法的时候,该方法会和该对象的内存地址/运行类型绑定
2、当调用对象属性时,没有动态绑定机制,哪里声明,那里使用
package com.dynamic;public class DynamicBinding {public static void main(String[] args) {//a 的编译类型 A,运行类型 BA a = new B();//向上转型System.out.println(a.sum());//40 -> 30System.out.println(a.sum1());//30 -> 20}}class A {//父类public int i = 10;//动态绑定机制:public int sum() {//父类sum()return getI() + 10;//20 + 10}public int sum1() {//父类sum1()return i + 10;//10 + 10}public int getI() {//父类getI()return i;}}class B extends A {//子类public int i = 20;// public int sum() {// return i + 20;// }public int getI() {//子类getI()return i;}// public int sum1() {// return i + 10;// }}
多态的应用
1、多态数组
数组的定义类型为父类类型,里面保存的实际元素类型为子类类型
应用实例:
现有一个继承结构如下:
要求创建1个Person对象、2个Student对象和2个Teacher对象,统一放在数组中,并调用say方法
应用实例升级:
如何调用子类特有的方法,比如Teacher有一个teach,Student有一个study怎么调用?
package com.polyarr;public class Person {//父类private String name;private int age;public Person(String name, int age) {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 String say() {//返回名字和年龄return name + "\t" + age;}}
package com.polyarr;public class Student extends Person {private double score;public Student(String name, int age, double score) {super(name, age);this.score = score;}public double getScore() {return score;}public void setScore(double score) {this.score = score;}//重写父类say@Overridepublic String say() {return "学生 " + super.say() + " score=" + score;}//特有方法public void study() {System.out.println("学生 " + getName() + " 正在学Java...");}}
package com.polyarr;public class Teacher extends Person {private double salary;public Teacher(String name, int age, double salary) {super(name, age);this.salary = salary;}public double getSalary() {return salary;}public void setSalary(double salary) {this.salary = salary;}//重写父类的say方法@Overridepublic String say() {return "老师 " + super.say() + " salary=" + salary;}//特有方法public void teach() {System.out.println("老师 " + getName() + " 正在将Java课程...");}}
package com.polyarr;public class PloyArray {public static void main(String[] args) {// 应用实例:// 现有一个继承结构如下:// 要求创建1个Person对象、2个Student对象和2个Teacher对象,统一放在数组中,并调用say方法Person[] persons = new Person[5];persons[0] = new Person("toms", 22);persons[1] = new Student("jack", 18, 100);persons[2] = new Student("smith", 19, 30.1);persons[3] = new Teacher("scott", 30, 200000);persons[4] = new Teacher("king", 25, 250000);//循环遍历多态数组,调用sayfor (int i = 0; i < persons.length; i++) {//提示:person[i]编译类型是 Person,运行类型是是根据实际情况有JVM来判断System.out.println(persons[i].say());//动态绑定机制if (persons[i] instanceof Student) {//判断person[i]的运行类型是不是StudentStudent student = (Student) persons[i];//向下转型student.study();//可以使用一条语句((Student) persons[i]).study();} else if (persons[i] instanceof Teacher) {Teacher teacher = (Teacher) persons[i];teacher.teach();} else if (persons[i] instanceof Person) {} else {System.out.println("你的类型有误,请自行检查");}}}}
运行结果
2、多态参数
方法定义的形参类型为父类类型,实参类型允许为子类类型
应用实例1:前面的主人喂动物
应用实例2:
定义员工类Employee,包含姓名和月工资[private],以及计算年工资getAnnual的方法。普通员工和经理继承了员工,经理类多了奖金bonus属性和管理manage方法,普通员工类多了work方法,普通员工和经理类要求分别重写getAnnual方法
测试类中添加一个方法showEmpAnnual(Employee e),实现获取任何员工对象的年工资,并在main方法中调用该方法[e.getAnnual()]
测试类中添加一个方法,testWork,如果是普通员工,则调用work方法,如果是经理,则调用manage方法
package com.polyparameter;public class Employee {private String name;private double salary;public Employee(String name, double salary) {this.name = name;this.salary = salary;}public String getName() {return name;}public void setName(String name) {this.name = name;}public double getSalary() {return salary;}public void setSalary(double salary) {this.salary = salary;}//得到年工资的方法public double getAnnual() {return 12 * salary;}}
package com.polyparameter;public class Worker extends Employee {public Worker(String name, double salary) {super(name, salary);}public void work() {System.out.println("普通员工 " + getName() + " is working");}@Overridepublic double getAnnual() {//因为普通员工没有其他收入,则直接调用父类方法return super.getAnnual();}}
package com.polyparameter;public class Manager extends Employee {private double bonus;public Manager(String name, double salary, double bonus) {super(name, salary);this.bonus = bonus;}public double getBonus() {return bonus;}public void setBonus(double bonus) {this.bonus = bonus;}public void manage() {System.out.println("经理 " + getName() + " is managing");}//重新获取年薪方法@Overridepublic double getAnnual() {return super.getAnnual() + bonus;}}
package com.polyparameter;public class PloyParameter {public static void main(String[] args) {Worker tom = new Worker("tom", 2900);Manager milan = new Manager("milan", 5000, 20000);PloyParameter ployParameter = new PloyParameter();ployParameter.showEmpAnnual(tom);ployParameter.showEmpAnnual(milan);ployParameter.testWork(tom);ployParameter.testWork(milan);}//showEmpAnnual(Employee e)//实现获取任何员工对象的年工资,并在main方法中调用该方法[e.getAnnual()]public void showEmpAnnual(Employee e) {System.out.println(e.getAnnual());//动态绑定机制}//添加一个方法,testWork,如果是普通员工,则调用work方法,如果是经理,则调用manage方法public void testWork(Employee e) {if (e instanceof Worker) {((Worker) e).work();//有向下转型操作} else if (e instanceof Manager) {((Manager) e).manage();//有向下转型操作} else {System.out.println("不做处理...");}}}
运行结果
Java笔记013-IDEA 包 访问修饰符 封装 继承 多态 Super 方法重写/覆盖(override) java的动态绑定机制