多态
什么是多态？
- 同类型的对象，表现出的不同形态
多态的表现形式
父类类型 对象名称 = 子类对象;多态的前提
- 有继承/实现关系
- 有父类引用指向子类对象
- 有方法重写
多态的好处
- 使用父类型作为参数，可以接受所有子类对象
- 体现多态的扩展性与便利
- 在多态形式下，右边对象可以实现解耦合，便于扩展和维护
package com.itheima.test34;
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 show() {
System.out.println(this.getName() + "," + this.getAge());
}
}
package com.itheima.test34;
public class Teacher extends Person{
@Override
public void show() {
System.out.println("老师" + getName() + "," + getAge());
}
}
package com.itheima.test34;
public class Student extends Person{
@Override
public void show() {
System.out.println("学生" + getName() + "," + getAge());
}
}
package com.itheima.test34;
public class Test {
public static void main(String[] args) {
Student s = new Student();
s.setName("zhangsan");
s.setAge(18);
Teacher t = new Teacher();
t.setName("lisi");
t.setAge(30);
register(s);
register(t);
}
public static void register(Person p) {
p.show();
}
}
运行结果：
多态调用成员的特点
- 变量调用：编译看左边，运行也看左边
- javac编译代码的时候，会看左边的父类中有没有这个变量，如果有，编译成功，如果没有，编译失败
- java运行代码的时候，实际获取的就是左边父类中成员变量的值
- 方法调用：编译看左边，运行看右边
- javac编译代码的时候，会看左边的父类中有没有这个方法，如果有，编译成功，如果没有，编译失败
- java运行代码的时候，实际上运行的是子类中的方法
多态调用成员的内存图解
多态的弊端
- 不能使用子类的特有功能
引用数据类型的类型转换
- 自动类型转换（小转大）
-
Animal a = new Dog();
-
- 强制类型转换（大转小）
-
Dog d = (Dog) a;if(a instanceof Dog d) {...} - 表示若a能够转换成Dog类型，就转换成Dog类型并自动创建一个变量进行接收；
-
强制类型转换能解决什么问题？
- 可以转换成真正的子类类型，从而调用子类独有功能
- 转换的时候用instanceof关键字进行判断
package com.itheima.test35;
public class Test {
public static void main(String[] args) {
Animal a = new Dog();
System.out.println(a.name);
a.show();
System.out.println("------------");
// 但是并不能调用子类的特有方法（父类没有的方法）
// 因此需要强制类型转换
// 第一种
// Dog d = (Dog) a;
// d.lookHome();
// 但是由于Animal a = new Dog();这一行代码的限制，a只能转换成Dog类型，不能转换成Cat类型
// 如果转换成Cat类型，就会报错，因此就有了第二种方法（JDK14以后）
// 会自动判断能够转换成哪种类型，并不会报错
// 第二种 instanceof关键字
//
if (a instanceof Dog d) {
d.lookHome();
} else if (a instanceof Cat c) {
c.catchMouse();
} else {
System.out.println("没有这个类型可以转换");
}
}
}
class Animal {
String name = "动物";
public void show() {
System.out.println("动物————show方法");
}
}
class Dog extends Animal {
String name = "狗";
@Override
public void show() {
System.out.println("狗————show方法");
}
public void lookHome() {
System.out.println("狗在看家");
}
}
class Cat extends Animal {
String name = "猫";
@Override
public void show() {
System.out.println("猫————show方法");
}
public void catchMouse() {
System.out.println("猫在抓老鼠");
}
}
运行结果：（第一种和第二种方法的运行结果是相同的）
多态的综合练习
根据需求完成代码:
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中调用特有方法？
package com.itheima.test36;
public class Animal {
/*
属性：
年龄，颜色
行为:
eat(String something)(something表示吃的东西)*/
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(getAge() + "岁的" + getColor() + "的动物正在吃" + something);
}
}
package com.itheima.test36;
public class Dog extends Animal {
/*1.定义狗类
属性：
年龄，颜色
行为:
eat(String something)(something表示吃的东西)
看家lookHome方法(无参数)*/
public Dog() {
}
public Dog(int age, String color) {
super(age, color);
}
@Override
public void eat(String something) {
System.out.println(getAge() + "岁的" + getColor() + "颜色的狗两只前腿死死的抱住" + something + "猛吃");
}
public void lookHome() {
System.out.println("狗在看家");
}
}
package com.itheima.test36;
public class Cat extends Animal {
/*2.定义猫类
属性：
年龄，颜色
行为:
eat(String something)方法(something表示吃的东西)
逮老鼠catchMouse方法(无参数)*/
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("猫抓老鼠");
}
}
package com.itheima.test36;
public class Person {
/*3.定义Person类//饲养员
属性：
姓名，年龄
行为：
keepPet(Dog dog,String something)方法
功能：喂养宠物狗，something表示喂养的东西
行为：
keepPet(Cat cat,String something)方法
功能：喂养宠物猫，something表示喂养的东西
生成空参有参构造，set和get方法*/
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("年龄为" + getAge() + "岁的" + getName() + "养了一只" + dog.getColor() + "颜色的" + dog.getAge() +"岁的狗");
// dog.eat(something);
// }
//
// public void keepPet(Cat cat, String something) {
// System.out.println("年龄为" + getAge() + "岁的" + getName() + "养了一只" + cat.getColor() + "颜色的" + cat.getAge() +"岁的猫");
// cat.eat(something);
// }
// 第二种
public void keepPet(Animal a, String something) {
if (a instanceof Dog dog) {
System.out.println("年龄为" + getAge() + "岁的" + getName() + "养了一只" + dog.getColor() + "颜色的" + dog.getAge() +"岁的狗");
dog.eat(something);
} else if (a instanceof Cat cat) {
System.out.println("年龄为" + getAge() + "岁的" + getName() + "养了一只" + cat.getColor() + "颜色的" + cat.getAge() +"岁的猫");
cat.eat(something);
}
}
}
package com.itheima.test36;
/*根据需求完成代码:
4.定义测试类(完成以下打印效果):
keepPet(Dog dog,String something)方法打印内容如下：
年龄为30岁的老王养了一只黑颜色的2岁的狗
2岁的黑颜色的狗两只前腿死死的抱住骨头猛吃
keepPet(Cat cat,String something)方法打印内容如下：
年龄为25岁的老李养了一只灰颜色的3岁的猫
3岁的灰颜色的猫眯着眼睛侧着头吃鱼
5.思考：
1.Dog和Cat都是Animal的子类，以上案例中针对不同的动物，定义了不同的keepPet方法，过于繁琐，能否简化，并体会简化后的好处？
2.Dog和Cat虽然都是Animal的子类，但是都有其特有方法，能否想办法在keepPet中调用特有方法？*/
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, "鱼");
}
}
运行结果：
包、final、权限修饰符、代码块
什么是包？
- 包就是文件夹。用来管理各种不同功能的java类，方便后期代码维护。
- 包名的规则：公司域名反写+包的作业，需要全部英文小写，见名知意。如：com.itheima.domain
使用其他类的规则
- 使用同一个包中的类时，不需要导包
- 使用java.lang包中的类时，不需要导包
- 其他情况需要导包
- 如果同时使用两个包中的同名类，需要用全类名
final
- final修饰方法：表示该方法是最终方法，不能被重写
-
final public void register() {}
-
- final修饰类：表示该类是最终类，不能被继承
-
final public class Student{}
-
- final修饰变量：叫做常量，只能被赋值一次
-
final private static String ADD_STUDENT = "1"; final private static String DELETE_STUDENT = "2"; final private static String UPDATE_STUDENT = "3"; final private static String QUERY_STUDENT = "4"; final private static String EXIT = "5";
-
- final都是写在最前面的，无论是修饰方法、类还是变量
常量
- 实际开发当中，常量一般作为系统的配置信息，方便维护，提高可读性
- 常量的命名规范：
- 单个单词：全部大写
- 多个单词：全部大写，单词之间用下划线隔开
细节：
- final修饰的变量如果是基本类型，那么变量存储的数据值不能发生改变
- final修饰的变量如果是引用类型：那么变量存储的地址值不能发生改变，但是对象内部的属性值可以改变
权限修饰符
- 权限修饰符：是用来控制一个成员能够被访问的范围的
- 可以修饰成员变量方法、构造方法、内部类
权限修饰符的分类
权限修饰符的使用规则
- 实际开发中，一般只用private和public
- 成员变量私有（private string name；）
- 方法公开（public static void register() {})
- 特例：如果方法中的代码是抽取其他方法中的共性代码，这个方法一般也私有
代码块
局部代码块
package com.itheima.test37;
public class CodeBlockDemo {
public static void main(String[] args) {
{
int a = 10;
System.out.println(a);
}// 当代码执行到这里时，变量a就会从内存中消失
}
}
构造代码块
- 写在成员位置的代码块
- 作用：可以把多个构造方法中重复的代码抽取出来
- 执行实际：我们在创建本类对象的时候会先执行构造代码块再执行构造方法
package com.itheima.test37;
public class Student {
private String name;
private int age;
// 构造代码块
// 1.写在成员位置的代码块
// 2.作用：可以把多个构造方法中重复的代码抽取出来
// 3.执行实际：我们在创建本类对象的时候会先执行构造代码块再执行构造方法
{
System.out.println("开始创造对象了");
}
public Student() {
// System.out.println("开始创造对象了");
System.out.println("空参构造");
}
public Student(String name, int age) {
// System.out.println("开始创造对象了");
System.out.println("有参构造");
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;
}
}
package com.itheima.test37;
public class CodeBlockDemo {
public static void main(String[] args) {
Student s = new Student();
Student s1 = new Student("zhangsan", 19);
}
}
运行结果：
但是由于这样在调用每一个构造方法都会执行构造代码块中的代码，不太灵活，因此有了以下两种做法
静态代码块
- 格式：static{}
- 特点：需要通过static关键字修饰，随着类的加载而加载，并且自动触发，只执行一次
- 使用场景：在类加载的时候，做一些数据初始化的时候使用
package com.itheima.test38;
public class Student {
private String name;
private int age;
// 执行时机
// 随着类的加载而加载，并且只执行一次
static {
System.out.println("静态代码块执行了");
}
public Student() {
System.out.println("空参构造");
}
public Student(String name, int age) {
System.out.println("有参构造");
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
}
package com.itheima.test38;
public class Test {
public static void main(String[] args) {
Student s1 = new Student();
Student s2 = new Student("zhangsan", 12);
}
}
运行结果：
可以看到，静态代码块中的代码只执行了一次
用户系统中的使用
这样就可以先在用户系统中先存入一些用户信息，不必每个都需要先注册才能登陆
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
