目录
instanceOf 比较操作符，用于判断对象的运行类型是否为XX类型或XX类型的子类型
面向对象编程(中级部分)
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);
//输出排序后的arr
System.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 - 1
for (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@4554617c
com.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.net.* //网络包，网络开发
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};
//比如对其进行排序
//传统方法是，自己编写排序(冒泡)
//系统是提供了相关的类，可以方便完成Arrays
Arrays.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的最上面，
// 一个类中最多只有一句package
package 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种访问修饰符的访问范围
| 访问级别 | 访问控制修饰符 | 同类 | 同包 | 子类 | 不同包 |
| 公开 | public | √ | √ | √ | √ |
| 受保护 | protected | √ | √ | √ | × |
| 默认 | 没有修饰符 | √ | √ | × | × |
| 私有 | private | √ | × | × | × |
使用的注意事项
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和默认，不能访问private
System.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-120年龄，工资不能直接查看，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-120年龄，
//工资不能直接查看，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;
}
//写一个方法，返回属性信息
@Override
public 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个属性设置为private
private 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) {
//创建Account
Account 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的方法，返回了n4
public 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");
}
//call
public 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的方法，返回了n4
public 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");
}
//call
public 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);//返回的就是39
System.out.println(son.getAge());//返回的就是39
System.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;
}
//返回Computer
public 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的比较
| No. | 区别点 | this | super |
| 1 | 访问属性 | 访问本类中的属性，如果本类没有此属性则从父类中继续查找 | 访问父类中的属性 |
| 2 | 调用方法 | 访问本类中的方法，如果本类没有此方法则从父类继续查找 | 直接访问父类中的方法 |
| 3 | 调用构造器 | 调用本类构造器，必须放在构造器的首行 | 调用父类构造器，必须放在子类构造器的首行 |
| 4 | 特殊 | 表示当前对象 | 子类中访问父类对象 |
方法重写/覆盖(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、方法的重写和重载的比较
| 名称 | 发生范围 | 方法名 | 形参列表 | 返回类型 | 修饰符 |
| 重载(overload) | 本类 | 必须一样 | 类型，个数或者顺序至少有一个不同 | 无要求 | 无要求 |
| 重写(override) | 父类 | 必须一样 | 相同 | 子类方法的返回类型和父类方法返回类型一样，或者是父类返回类型的子类 | 子类方法不能缩小父类方法的访问权限(可以扩大) |
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;
}
//say
public 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{
@Override
public void cry() {
System.out.println("Cat cry() 小猫喵喵叫...");
}
}
package com.objectpoly;
public class Dog extends Animal{
@Override
public void cry() {
System.out.println("Dog cry() 小狗汪汪叫...");
}
}
package com.objectpoly;
public class PolyObject {
public static void main(String[] args) {
//体验对象多态特点
//animal 编译类型就是 Animal，运行类型Dog
Animal animal = new Dog();
//因为运行时，这时就执行到该行时，animal运行类型是Dog，所以cry就是Dog的cry
animal.cry();//小狗汪汪叫
//animal 编译类型 Animal，运行类型就是Cat
animal = 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,world
animal.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,world
animal.sleep();//睡
//希望可以调用Cat的 catchMouse方法
//多态的向下转型
//(1)语法：子类类型引用名 = (子类类型)父类引用;
//cat 的编译类型 Cat，运行类型 Cat
Cat 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);//看编译类型 10
Sub 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);//true
System.out.println(bb instanceof AA);//true
//aa 编译类型 AA，运行类型 BB
AA aa = new BB();
System.out.println(aa instanceof AA);//true
System.out.println(aa instanceof BB);//true
Object obj = new Object();
System.out.println(obj instanceof AA);//false
String 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);//20
s.display();//20
Base b = s;
System.out.println(b == s);//true
System.out.println(b.count);//10
b.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，运行类型 B
A a = new B();//向上转型
System.out.println(a.sum());//40 -> 30
System.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
@Override
public 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方法
@Override
public 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);
//循环遍历多态数组，调用say
for (int i = 0; i < persons.length; i++) {
//提示:person[i]编译类型是 Person，运行类型是是根据实际情况有JVM来判断
System.out.println(persons[i].say());//动态绑定机制
if (persons[i] instanceof Student) {//判断person[i]的运行类型是不是Student
Student 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");
}
@Override
public 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");
}
//重新获取年薪方法
@Override
public 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("不做处理...");
}
}
}
运行结果
230
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
