2021-04-06

Java学习

day11
目录

1. 多态
2. 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