Java学习
day11
目录
- 多态
- 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());
}
}
运行结果:
tip:2020080605006