目录
多态
多态： 是指同一行为，具有多个不同表现形式。
前提
-
有继承或者实现关系
-
方法的重写
-
父类引用指向子类对象
父类类型：指子类对象继承的父类类型，或者实现的父接口类型。
注意
当一个方法的形参是一个类，可以传递这个类所有的子类对象。
当一个方法的形参是一个接口，可以传递这个接口所有的实现类对象。
而且多态还可以根据传递的不同对象来调用不同类中的方法。
调用成员变量时：编译看左边，运行看左边
调用成员方法时：编译看左边，运行看右边
代码示例：
Fu f = new Zi()；
//java在编译代码时，会看左边的父类中有没有name这个变量，没有就报错
//java在运行代码时，实际获取左边父类name变量的值
System.out.println(f.name);
//编译看左边的父类中有没有show这个方法，没有就报错
//在实际运行的时候，运行的是右边子类中的show方法
f.show();内存中永远先加载父类的字节码文件
多态的优势和弊端
优势：
- 在多态形形式下，右边对象可以实现解耦合，便于扩展和维护
- 定义方法时，使用父类类型作为参数，可以接收所有子类对象，体现多态的扩展性与便利（重要）
弊端
多态编译阶段是看左边父类类型，如果子类有些独有的功能，此时多态的写法就无法访问子类独有功能了。
class Animal{
public void eat()｛
System.out.println("动物吃东西！")
｝
}
class Cat extends Animal {
public void eat() {
System.out.println("吃鱼");
}
public void catchMouse() {
System.out.println("抓老鼠");
}
}
class Dog extends Animal {
public void eat() {
System.out.println("吃骨头");
}
}
class Test{
public static void main(String[] args){
Animal a = new Cat();
a.eat();
a.catchMouse();//编译报错，编译看左边，Animal没有这个方法
}
}解决办法：引用类型转换
引用类型转换
为什么要转型
多态的写法就无法访问子类独有功能了。
当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。也就是说，不能调用子类拥有，而父类没有的方法。不能编译也不能运行。为了调用子类特有的方法，必须做向下转型。
基本数据类型转换
自动转换: 范围小的赋值给范围大的-自动完成:double d = 5;
强制转换: 范围大的赋值给范围小的-强制转换:int i = (int)3.14
多态的转型分为向上转型（自动转换）与向下转型（强制转换）两种。
向上转型（自动转换）
-
向上转型：多态本身是子类类型向父类类型向上转换（自动转换）的过程，这个过程是默认的。 当父类引用指向一个子类对象时，是向上转型。
父类类型 变量名 = new 子类类型();
如：Animal a = new Cat();原因是：父类类型相对与子类来说是大范围的类型，Animal是动物类，是父类类型。Cat是猫类，是子类类型。Animal类型的范围当然很大，包含一切动物。所以子类范围小可以直接自动转型给父类类型的变量。
向下转型（强制转换）
-
向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的。 一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，是向下转型。
子类类型 变量名 = (子类类型) 父类变量名;
如:Aniaml a = new Cat();
Cat c =(Cat) a; 案例演示
定义类：
abstract class Animal {
abstract void eat();
}
class Cat extends Animal {
public void eat() {
System.out.println("吃鱼");
}
public void catchMouse() {
System.out.println("抓老鼠");
}
}
class Dog extends Animal {
public void eat() {
System.out.println("吃骨头");
}
public void watchHouse() {
System.out.println("看家");
}
}定义测试类：
public class Test {
public static void main(String[] args) {
// 向上转型
Animal a = new Cat();
a.eat(); // 调用的是 Cat 的 eat
// 向下转型
Cat c = (Cat)a;
c.catchMouse(); // 调用的是 Cat 的 catchMouse
}
}转型的异常
转型过程中的问题，如下代码
public class Test {
public static void main(String[] args) {
// 向上转型
Animal a = new Cat();
a.eat(); // 调用的是 Cat 的 eat
// 向下转型
Dog d = (Dog)a;
d.watchHouse(); // 调用的是 Dog 的 watchHouse 【运行报错】
}
}这段代码可以通过编译，但是运行时，却报出了 ClassCastException ，类型转换异常！
因为创建了Cat类型对象，不能转换成Dog对象
instanceof关键字
为了避免ClassCastException的发生，Java提供了 instanceof 关键字，给引用变量做类型的校验，格式如下：
变量名 instanceof 数据类型
如果变量属于该数据类型或者其子类类型，返回true。
如果变量不属于该数据类型或者其子类类型，返回false。
所以，转换前，我们最好先做一个判断，代码如下：
public class Test {
public static void main(String[] args) {
// 向上转型
Animal a = new Cat();
a.eat(); // 调用的是 Cat 的 eat
// 向下转型
if (a instanceof Cat){
Cat c = (Cat)a;
c.catchMouse(); // 调用的是 Cat 的 catchMouse
} else if (a instanceof Dog){
Dog d = (Dog)a;
d.watchHouse(); // 调用的是 Dog 的 watchHouse
}
}
}instanceof新特性
JDK14的时候提出了新特性，把判断和强转合并成了一行
//新特性
//先判断a是否为Dog类型，如果是，则强转成Dog类型，转换之后变量名为d
//如果不是，则不强转，结果直接是false
if(a instanceof Dog d){
d.lookHome();
}else if(a instanceof Cat c){
c.catchMouse();
}else{
System.out.println("没有这个类型，无法转换");
}多态中不能使用子类特有的功能，可以通过类型转换调用子类独有的功能，当转换类型和真实对象类型不一致时会报错，转换时可以使用instanceof关键字进行判断
综合练习
需求：根据需求完成代码:
1.定义狗类
属性：
年龄，颜色
行为:
eat(String something)(something表示吃的东西)
看家lookHome方法(无参数)
2.定义猫类
属性：
年龄，颜色
行为:
eat(String something)方法(something表示吃的东西)
逮老鼠catchMouse方法(无参数)
3.定义Person类//饲养员
属性：
姓名，年龄
行为：
keepPet(Dog dog,String something)方法
功能：喂养宠物狗，something表示喂养的东西
行为：
keepPet(Cat cat,String something)方法
功能：喂养宠物猫，something表示喂养的东西
生成空参有参构造，set和get方法
4.定义测试类(完成以下打印效果):
keepPet(Dog dog,String somethind)方法打印内容如下：
年龄为30岁的老王养了一只黑颜色的2岁的狗
2岁的黑颜色的狗两只前腿死死的抱住骨头猛吃
keepPet(Cat cat,String somethind)方法打印内容如下：
年龄为25岁的老李养了一只灰颜色的3岁的猫
3岁的灰颜色的猫眯着眼睛侧着头吃鱼
5.思考：
1.Dog和Cat都是Animal的子类，以上案例中针对不同的动物，
定义了不同的keepPet方法，过于繁琐，能否简化，并体会简化后的好处？
2.Dog和Cat虽然都是Animal的子类，但是都有其特有方法，
能否想办法在keepPet中调用特有方法？画图分析：
代码示例：
//动物类（父类）
public class Animal {
private int age;
private String color;
public Animal() {
}
public Animal(int age, String color) {
this.age = age;
this.color = color;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public void eat(String something){
System.out.println("动物在吃" + something);
}
}
//猫类（子类）
public class Cat extends Animal {
public Cat() {
}
public Cat(int age, String color) {
super(age, color);
}
@Override
public void eat(String something) {
System.out.println(getAge() + "岁的" + getColor() + "颜色的猫眯着眼睛侧着头吃" + something);
}
public void catchMouse(){
System.out.println("猫抓老鼠");
}
}
//狗类（子类）
public class Dog extends Animal {
public Dog() {
}
public Dog(int age, String color) {
super(age, color);
}
//行为
//eat(String something)(something表示吃的东西)
//看家lookHome方法(无参数)
@Override
public void eat(String something) {
System.out.println(getAge() + "岁的" + getColor() + "颜色的狗两只前腿死死的抱住" + something + "猛吃");
}
public void lookHome(){
System.out.println("狗在看家");
}
}
//饲养员类
public class Person {
private String name;
private int age;
public Person() {
}
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 void keepPet(Dog dog, String something) {
System.out.println("年龄为" + age + "岁的" + name + "养了一只" + dog.getColor() + "颜色的" + dog.getAge() + "岁的狗");
dog.eat(something);
}
//饲养猫
public void keepPet(Cat cat, String something) {
System.out.println("年龄为" + age + "岁的" + name + "养了一只" + cat.getColor() + "颜色的" + cat.getAge() + "岁的猫");
cat.eat(something);
}*/
//想要一个方法，能接收所有的动物，包括猫，包括狗
//方法的形参：可以写这些类的父类 Animal
public void keepPet(Animal a, String something) {
if(a instanceof Dog d){
System.out.println("年龄为" + age + "岁的" + name + "养了一只" + a.getColor() + "颜色的" + a.getAge() + "岁的狗");
d.eat(something);
}else if(a instanceof Cat c){
System.out.println("年龄为" + age + "岁的" + name + "养了一只" + c.getColor() + "颜色的" + c.getAge() + "岁的猫");
c.eat(something);
}else{
System.out.println("没有这种动物");
}
}
}
//测试类
public class Test {
public static void main(String[] args) {
//创建对象并调用方法
/* Person p1 = new Person("老王",30);
Dog d = new Dog(2,"黑");
p1.keepPet(d,"骨头");
Person p2 = new Person("老李",25);
Cat c = new Cat(3,"灰");
p2.keepPet(c,"鱼");*/
//创建饲养员的对象
Person p = new Person("老王",30);
Dog d = new Dog(2,"黑");
Cat c = new Cat(3,"灰");
p.keepPet(d,"骨头");
p.keepPet(c,"鱼");
}
}包
包就是文件夹，用来管理各种不同功能的java类，方便管理和维护。
包名的命名规范：
路径名.路径名.xxx.xxx
// 例如：com.itheima.oa
-
包名一般是公司域名的倒写。例如：黑马是www.itheima.com,包名就可以定义成com.itheima.技术名称。
-
包名必须用”.“连接。
-
包名的每个路径名必须是一个合法的标识符，而且不能是Java的关键字。
使用其他类的规则
- 使用同一个包中的类时，不需要导包。
- 使用java.lang包中的类时，不需要导包。
- 其他情况都需要导包
- 如果同时使用两个包中的同名类，需要用全类名
假设demo1和demo2中都有一个Student该如何使用？
代码示例：
//使用全类名的形式即可。
//全类名：包名 + 类名
//拷贝全类名的快捷键：选中类名crtl + shift + alt + c 或者用鼠标点copy，再点击copy Reference
com.itheima.homework.demo1.Student s1 = new com.itheima.homework.demo1.Student();
com.itheima.homework.demo2.Student s2 = new com.itheima.homework.demo2.Student();权限修饰符
权限修饰符：用来控制一个成员能够被访问的范围
可以修饰成员变量、方法、构造方法、内部类
public：公共的，所有地方都可以访问。
protected：本类 ，本包，其他包中的子类都可以访问。
默认（没有修饰符）：本类 ，本包可以访问。
注意：默认是空着不写，不是default
private：私有的，当前类可以访问。
作用范围：public > protected > 默认 > private
权限修饰符的使用规则
实际开发中，一般只用private和public成员变量私有方法公开
特例:如果方法中的代码是抽取其他方法中共性代码，这个方法一般也私有。
编写代码时，如果没有特殊的考虑，建议这样使用权限：
成员变量使用
private，隐藏细节。构造方法使用
public，方便创建对象。成员方法使用
public，方便调用方法。
final
-
final： 不可改变，最终的含义。可以用于修饰类、方法和变量。
-
类：表明是最终类，不能被继承。
-
方法：表明是最终方法，不能被重写。
-
变量：叫做常量，只能被赋值一次。
-
使用方式
修饰类
final修饰的类，不能被继承。
格式如下：
final class 类名 {
}代码
final class Fu {
}
// class Zi extends Fu {} // 报错,不能继承final的类查询API发现像 public final class String 、public final class Math 、public final class Scanner 等，都是被final修饰的，目的就是供我们使用，而不让改变其内容。
修饰方法
final修饰的方法，不能被重写。 格式如下：
修饰符 final 返回值类型 方法名(参数列表){
//方法体
}代码
class Fu2 {
final public void show1() {
System.out.println("Fu2 show1");
}
public void show2() {
System.out.println("Fu2 show2");
}
}
class Zi2 extends Fu2 {
// @Override
// public void show1() {
// System.out.println("Zi2 show1");
// }
@Override
public void show2() {
System.out.println("Zi2 show2");
}
}修饰变量-局部变量
-
局部变量——基本类型 基本类型的局部变量，被final修饰后，只能赋值一次，不能再更改。代码如下：
public class FinalDemo1 {
public static void main(String[] args) {
// 声明变量，使用final修饰
final int a;
// 第一次赋值
a = 10;
// 第二次赋值
a = 20; // 报错,不可重新赋值
// 声明变量，直接赋值，使用final修饰
final int b = 10;
// 第二次赋值
b = 20; // 报错,不可重新赋值
}
}思考，下面两种写法，哪种可以通过编译？
写法1：
final int c = 0;
for (int i = 0; i < 10; i++) {
c = i;
System.out.println(c);
}写法2：
for (int i = 0; i < 10; i++) {
final int c = i;
System.out.println(c);
}根据 final 的定义，写法1报错！写法2，为什么通过编译呢？因为每次循环，都是一次新的变量c。
修饰变量-成员变量
成员变量涉及到初始化的问题，初始化方式有显示初始化和构造方法初始化，只能选择其中一个：
-
显示初始化(在定义成员变量的时候立马赋值)（常用）；
public class Student {
final int num = 10;
}-
构造方法初始化(在构造方法中赋值一次)（不常用，了解即可）。
注意：每个构造方法中都要赋值一次！
public class Student {
final int num = 10;
final int num2;
public Student() {
this.num2 = 20;
// this.num2 = 20;
}
public Student(String name) {
this.num2 = 20;
// this.num2 = 20;
}
}被final修饰的常量名称，一般都有书写规范，所有字母都大写。
public static void main(String[] args) {
/*
final 修改基本数据类型:记录的值不能发生改变
final 修饰引用数据类型:记录的地址值不能发生改变，内部的属性值还是可以改变的
*/
final double PI = 3.14;
//创建对象
final Student S = new Student( name: "zhangsan", age:23);
//记录的地址值不能发生改变，内部的属性值还是可以改变的
//S = new student();
S.setName("李四");
S.setAge(24);
System.out.print1n(S.getName()+ "," + S.getAge());
//李四，24
}
扫一扫
1087
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
