Java基础_基础语法知识8

Posted 2021-01-28 德墨特尔

面向对象

1.final关键字
(1).final关键字意思是最终的，最后的。

(2).final关键字可以修饰类，方法以及变量。

(3).final关键字修饰类，这一个类就编程最终类，这一个时候最终类不可以被继承。
final关键字修饰方法，该方法不能够被重写，以及覆盖。
final关键字修饰变量，这一个时候该变量就是一个常量，也就是不可以改变值。

(4).final关键字在继承中的使用测试:
//父类
public class Father {
public int num = 10;
public final int num1 = 20;
}
//子类以及测试
public class Son extends Father{

public void sonTest(){
num = 20;
System.out.println("子类访问的变量是:"+num);
//num1 = 30; 报错，这里面的num1访问的其实是flather父类中的 变量num1，无法未常量赋值，报错
//System.out.println("子类访问的变量是:"+num1);
}


public static void main(String[] args) {
Son s = new Son();
s.sonTest();
}
}

(5).final关键字的相关测试:
修饰的是基本类型，基本类型的值不可以改变
修饰的是引用类型，引用类型的地址值不可以改变。但是该对象的堆内存值是可以改变的。


//代码测试
public class Student {
int age = 10;

public static void main(String[] args) {
int x = 10;
x = 100;
System.out.println(x);

final int y = 20;
System.out.println(y);
System.out.println("-------------------");

//局部变量是引用类型
Student st = new Student();
System.out.println(st.age);
st.age = 200;
System.out.println(st.age);
System.out.println("--------------------");

//final关键字修饰引用类型，实质保证的是引用类型的地址值不改变，修饰一般类型，那么就是值不改变
final Student sdt = new Student();
System.out.println(sdt.age);
sdt.age = 300;
System.out.println(sdt.age);
System.out.println("---------------------");

//报错，无法给最终变量分配值
//sdt =new Student();
}
}

(6).final修饰的变量的初始化时机
A:被final修饰的变量只能够赋值一次；
B:final修饰的变量的初始化时机是在构造方法之前完毕。(非静态的常量)

 

2.面向对象多态的前提和条件

(1).多态的概述
什么是多态？多态就是某一个事务，在不同的时刻表现出来的不同形态。

举例:
狗的多态表现:
狗可以是狗的类型。也就是 dog dog = new dog();
狗也是动物的类型,狗也是属于一种动物。也就是 动物 dog = new dog();

水的三态变化
水是属于水类型。 water wt = new water();
水汽也是属于水的类型，其实质也是水。水汽 wt = new water();
冰也是属于水的类型，其实质也是水。 冰 wt = new water();

(2).多态的前提
A:俩个类必须有继承的关系。
B:有方法的重写。
没有方法的重写，那么这俩个类之间的关系就没有意义。
C:有父类的引用指向子类。
父类 f = new 子类;

(3).一个多态的基本例子(多态中的成员访问特点)
A:成员变量
编译看左边,运行看左边。
B:构造方法
创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化。
C:成员方法
编译看左边,运行看右边。
D:静态方法
编译看左边,运行看左边。
(静态和类相关，算不上重写，所以，访问还是左边)

由于成员方法存在着方法重写，所以它运行看右边。

(4).代码实现:
//父类
public class Father {
public int num = 100;
public void show(){
System.out.println("show fu");
}
public static void function(){
System.out.println("function father");
}
}

//子类以及测试
public class Son extends Father{

public int num = 200;
public int num2 = 1000;

public void show(){
System.out.println("show zi");
}

public void method(){
System.out.println("method zi");
}

public static void function(){
System.out.println("function son");
}

public static void main(String[] args) {
Father f = new Son();
//编译看左边,运行看左边。输出结果:100
System.out.println(f.num);
//找不到符号
//System.out.println(f.num2);
//show zi
f.show();
//报错，找不到方法
//f.method();
f.function();
}
}

//运行结果:
100
show zi
function father

(5).多态的好处
A:提高了代码的维护性(由继承保证)
B:提高了代码的扩展性(由多态保证)

代码实现:[*****]

Animal.java

public class Animal {
public void eat(){
//System.out.println("eat");
}
public void sleep(){
//System.out.println("sleep");
}
}

//扩展类1
Dog.java
public class Dog extends Animal{

public void eat(){
System.out.println("狗吃肉");
System.out.println("狗具体吃什么肉还可以在这里面添加");
}

public void sleep(){
System.out.println("狗趴着睡觉");
System.out.println("狗如何睡觉方法还可以在这里面添加");
}
}

//扩展类2
public class Cat extends Animal{

public void eat(){
System.out.println("猫吃鱼");
}

public void sleep(){
System.out.println("猫躺着睡觉");
}
}

//操作的工具类
//针对动物进行操作的工具类
public class AnimalTools {

//私有化构造
private AnimalTools(){}

public static void UseAnimal(Animal a){
a.eat();
a.sleep();

}
}

//测试类
public class TestDemo {
public static void main(String[] args) {
Cat c = new Cat();
Cat c2 = new Cat();
AnimalTools.UseAnimal(c);
AnimalTools.UseAnimal(c2);
System.out.println("---------");
Dog d = new Dog();
Dog d1 = new Dog();
AnimalTools.UseAnimal(d);
AnimalTools.UseAnimal(d1);

}
}

//由上面的代码可以看出，多态其实就是一个树形结构的数据结构，从根(父类)到每一个具体的叶子(子类或者是实现类)，我们
可以通过访问根的方式去访问每一个叶子节点。

(6).多态的弊端
只能够使用父类中定义过的方法，不能够使用子类的特有方法，也就是说子类如果要定义一个自己特有的方法，那么这个就必须
在父类中也有相同的方法声明。

3.多态中的转型问题[*****]

(1).为什么会出现多态中的转型？
多态中的转型问题主要是为了解决多态的弊端。为了能够让子类自己也能够使用子类的特有功能这一个时候就需要把父类和
子类之间进行一个按照需求的转化。

(2).向上转型
Fu f = new Zi();
向下转型
Zi z = (Zi) f; //但是要求f必须是能够转化为子的

4.面向对象多态案例
//父类
public class Animal {
public void eat(){
//System.out.println("eat");
}
public void sleep(){
//System.out.println("sleep");
}

}

//俩个子类
//狗类
public class Dog extends Animal{

public void eat(){
System.out.println("狗吃肉");
System.out.println("狗具体吃什么肉还可以在这里面添加");
}

public void sleep(){
System.out.println("狗趴着睡觉");
System.out.println("狗如何睡觉方法还可以在这里面添加");
}

//狗自己特有的方法
public void lookHome(){
System.out.println("小狗可以看家");
}
}

//猫类
public class Cat extends Animal{

public void eat(){
System.out.println("猫吃鱼");
}

public void sleep(){
System.out.println("猫躺着睡觉");
}

//猫自己特有的
public void catchMouse(){
System.out.println("小猫可以抓老鼠");
}
}

//父类的工具类
//针对动物进行操作的工具类
public class AnimalTools {

//私有化构造
private AnimalTools(){}

public static void UseAnimal(Animal a){
a.eat();
a.sleep();

}
}

//测试类
public class TestDemo {
public static void main(String[] args) {
Animal cat = new Cat();
//通用方法调用
AnimalTools.UseAnimal(cat);
//向下转型
Cat cat2 = (Cat)cat;
cat2.catchMouse();
System.out.println("------------------");
Animal dog = new Dog();
AnimalTools.UseAnimal(dog);
Dog dog2 = (Dog) dog;
dog2.lookHome();
}
}