第十一课时

目录

多态
final修饰符
1、多态
1.1、多态的概述
什么是多态: 同一个对象，在不同时刻表现出来的不同形态。
多态的前提: 要有继承或实现关系要有方法的重写要有父类引用指向子类对象。
格式: 父类名称 对象名 ＝ new 子类名称（）
1.2、多态中的成员方法的特点
成员方法: new 的谁，就先用谁
成员访问特点
成员变量 编译看父类，运行看父类
成员方法 编译看父类，运行看子类
1.3、多态的好处和弊端好处:
好处: 提高程序的扩展性。定义方法时候，使用父类型作为参数，在使用的时候，使用具体的子类型参与操作。
弊端: 不能使用子类的特有成员。
1.4、多态的转型
向上转型……父类引用指向子类对象就是向上转型
向下转型……格式：子类型 对象名=(子类型)父类引用;
1.5、例一:

①父类
package com.hg.demo01;

public class Fu {
public void method() {
System.out.println(“这是父类方法”);
}
public void methodFu() {
System.out.println(“这是父类特有方法”);
}
}
②子类
package com.hg.demo01;

public class Zi extends Fu {
public void method() {
System.out.println(“这是一个子类方法”);
}
public void methodFu() {
System.out.println(“这是父类特有方法”);
}
public void methodZi() {
System.out.println(“父子类的特有方法”);
}
}
③
package com.hg.demo01;
/ / 代码中体现多态：父类应用指向子类对象
public class Demo01Multi {
public static void main(String[] args) {
//类型 变量名称 = 常量
//int num = 5;
//类型
Fu fu = new Fu();
fu.method();
fu.methodFu();
System.out.println("=======");

Zi zi = new Zi();
zi.method();
zi.methodFu();
zi.methodZi();
System.out.println("=======");

//类似于强制类型转换
//double num = 5f;
Fu obj = new Zi();
obj.method();//子类方法
obj.methodFu();

}
例二:
①父类
package com.hg.demo02;

public class Fu {
int num = 10;
public void showNum() {
System.out.println(“父类方法”+num);
}
public void method() {
System.out.println(“父类方法”);
}
public void methodFu() {
System.out.println(“父类特有方法”);
}

}
②子类
package com.hg.demo02;

public class Zi extends Fu{
int num = 20;
int age = 18;

public void showNum() {
System.out.println(“类方法”+num);
}
public void method() {
System.out.println(“子类方法”);
}
public void methodZi() {
System.out.println(“子类特有方法”);
}
③
package com.hg.demo02;
/*
*

访问成员变量的两种方法

1、直接通过对象名称访问

2、通过成分方法直接访问

*/
public class Demo02MultiField {
public static void main(String[] args) {
//直接访问：看等号左边是谁，就访问谁。没有则向上找
Fu obj = new Zi();
System.out.println(obj.num);//父 10
//System.out.println(obj.age);错误用法
System.out.println("==========");

obj.showNum();
//成员方法
④
package com.hg.demo02;
/*

成员方法：
new的谁，就先用谁

对比
1、成员变量 编译看左边，运行还看左边
2、成员方法 编译看左边，运行看右边
*/
public class Demo02MultiMethod {
public static void main(String[] args) {
Fu obj = new Zi();
obj.method();

obj.methodFu();
例三:
①先定义一个动物类
package com.hg.Demo03;

public abstract class Animal {
public abstract void eat();
}
②再定义一个猫
package com.hg.Demo03;

public class Cat extends Animal{
@Override
public void eat() {
System.out.println(“猫吃老鼠”);
}
public void catchMouse() {
System.out.println(“猫抓老鼠”);
}

}
③再定义一个狗
package com.hg.Demo03;

public class Dog extends Animal{
@Override
public void eat() {
System.out.println(“狗吃骨头”);
}

public void watchHouse() {
System.out.println(“狗看家”);
}
④
package com.hg.Demo03;
//向上类型转换总是安全的，但是也有缺陷 原来子类的特有功能不能使用了
public class Demo03Main {
public static void main(String[] args) {
//类似于 隐式类型转换
Animal animal = new Cat();
animal.eat();

//向下类型转换  由父类型转换为子类型  还原
Cat cat = (Cat) animal;
cat.catchMouse();

}
⑤
package com.hg.Demo03;

public class Demo03Instancof {
public static void main(String[] args) {
Animal animal = new Dog();
animal.eat();
giveMeAPet(animal);
}
public static void giveMeAPet(Animal animal)
{
if(animal instanceof Dog)
{
Dog dog = (Dog) animal;
dog.watchHouse();
}
if(animal instanceof Cat)
{
Cat cat = (Cat) animal;
cat.catchMouse();
}

2、final 修饰符
2.1、定义:
final修饰符可用于类、方法和变量。用final修饰的类不能被扩展，也就是表示类不可被继承。final用于变量前，表示它是只能一次赋值的变量，如果初始化了，则就是常量，即final修饰的变量的内容不可更改。因此，声明final修饰的变量时必须将其初始化。声明为final的变量不会在每个实例中都占用内存，即可以认为final修饰的变量就像是常量。
2.2、final修饰符
①用来修饰一个类
②用来修饰一个方法
③用来修饰一个局部变量
④用来修饰一个成员变量
2.3、应用
①
package com.hg.demo04;
//被final 修饰的类是一个最终的类 （太监类：没有儿子）
//如果一个类被final修饰 所有的成员方法无法进行覆盖重写。

public final class MyClass {
public void method() {
System.out.println(“执行方法”);
}
}
②统一定义一个
package com.hg.demo04;

public class MySuClass{
}
③先定义一个父类
package com.hg.demo04;
//final 修饰方法的时候，该方法是最终方法 不能被覆盖重写。
public abstract class Fu {
public void method() {
System.out.println(“父类方法”);
}
public abstract /final/ void methodAbs();
}
④再定义一个子类
package com.hg.demo04;

public class Zi extends Fu {
/*
@Override
public void method() {
System.out.println(“子类方法”);
}
*/
public void methodAbs() {
}
}
⑤又定义一个学生
package com.hg.demo04;

public class Student {
private String name;

public Student() {

}
public Student(String name) {
this.name=name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
⑥在定义一个人
package com.hg.demo04;
/*

final 修饰成员变量
同样该值不能改变
1、由于成员变量具有默认值，所以使用final后，必须手动赋值
2、对于final的成员变量。要么直接赋值，要么通过构造方法赋值。
/
public class Person {
private final String name;
public Person() {
name=“小曾”;
}
public Person(String name) {
this.name=name;
}
public String getName() {
return name;
}
}
⑦
package com.hg.demo04;
/
*final
1、用来修饰一个类
2、用来修饰一个方法
3、用来修饰一个局部变量
4、用来修饰一个成员变量
*/
public class Demo04Final {
public static void main(String[] args) {
int num1 = 10;
System.out.println(num1);
num1 = 100;
System.out.println(num1);

final int num2 = 200;
System.out.println(num2);
//num2 = 2000;错误写法

final int num3;
num3 = 2000;
System.out.println("==========");
Student stu1 = new Student("zhangyanju");
System.out.println(stu1);
System.out.println(stu1.getName());

stu1 = new Student("小黄");
System.out.println(stu1);
System.out.println(stu1.getName());
System.out.println("==================");
final Student stu2 = new Student("jiangxin");
System.out.println(stu2);
System.out.println(stu2.getName());

stu2.setName("猪猪");
System.out.println(stu2);
System.out.println(stu2.getName());
System.out.println("==================");

Person person = new Person("小家伙");
System.out.println(person.getName());

}