final关键字：final是最终的意思，可以修饰类，变量，成员方法
1. final 修饰类, 该类就不能被继承
2. final 修饰方法， 该方法就不能在子类中被覆盖
3. final 修饰变量
a. final修饰局部变量, 该局部变量，只能被赋值一次且仅一次
b final修饰成员变量，我们必须保证，在对象创建完毕之前，我们自己必须给该
成员变量赋值一次，且仅一次
被final修饰的变量，其实就变成了一个自定义常量
a. 因为其值在程序运行期间不能被改变
b. 自定义体现在，常量的名字是我们自定义的
注意事项:
如果我们定义多个构造方法，而且我们是通过构造方法给final修饰的成员变量赋值，
一定要保证，每个构造方法，都要给final修饰的成员变量赋初值
public class Demo1 {
}
final class A {}
// 被final修饰的类，不能被继承
//class B extends A{}
class Father {
public final void method() {
System.out.println("method");
}
}
class TestFinal extends Father {
// @Override
// public void method() {
// System.out.println("method");
// }
final int finalValue1;
final double finalValue2;
// 通过成员变量的初始化语句，在对象创建完毕之前，给final修饰的成员变量赋初值
final boolean finalValue3 = true;
{
// 利用构造代码块，在对象创建完毕之前，给final修饰的成员变量赋初值
finalValue2 = 200;
//finalValue2 = 89;
}
public TestFinal() {
// 利用构造方法，在对象创建完毕之前，final修饰的成员变量赋初值
finalValue1 = 100;
}
public TestFinal(int finalValue1) {
this.finalValue1 = finalValue1;
}
/*
测试被final修饰的局部变量
*/
public void testLocalVariable() {
final int a = 100;
System.out.println();
//a = 900;
// final 修饰的局部变量只能被赋值一次，且仅一次
//a = 10;
// 自定义常量
}
}
二、多态
/*
多态的好处
提高了程序的维护性(由继承保证)
提高了程序的扩展性(由多态保证)
假设，先在有科学家要研究动物的声音
a. 让动物发出叫声
b. 收集动物的叫声
c. 研究收集到的声音
一开始，科学家之研究猫和狗的声音，过了一段时间，科学家想收集新的动物的声音猪的声音
*/
public class Demo2Benefit {
public static void main(String[] args) {
Dog dog = new Dog();
// collectDogSound(dog);
//
Cat cat = new Cat();
// collectCatSound(cat);
collectAllSound(dog);
collectAllSound(cat);
// 收集猪的声音
Pig pig = new Pig();
collectAllSound(pig);
}
// 定义方法研究狗的声音
public static void collectDogSound(Dog dog) {
// 狗发出叫声
dog.shout();
// 收集声音
// 研究声音
}
/*
研究猫的声音
*/
public static void collectCatSound(Cat cat) {
// 猫发出叫声
cat.shout();
// 收集声音
// 研究声音
}
/*
收集并研究猫，狗的声音并研究
*/
public static void collectAllSound(Animal animal) {
// 这里会发生多态
animal.shout();
}
}
class Animal {
public void shout() {
System.out.println("动物的叫声");
}
}
class Dog extends Animal {
public void shout() {
System.out.println("汪汪汪");
}
}
class Cat extends Animal {
public void shout() {
System.out.println("喵喵喵");
}
}
class Pig extends Animal {
public void shout() {
System.out.println("猪叫");
}
}
package com.cskaoyan.polymorphism;
/*
Java语言中的多态指什么呢？ “同一个对象”的行为，在不同的时刻或条件下，表现出不同的效果。
发生多态的条件：
a. 继承
b. 方法覆盖
c. 父类引用指向子类对象
多态中的成员访问特征
成员变量
编译看左边，运行看左边
成员方法(多态效果)
编译看左边，运行看右边
解释：
1. 编译看左边： 父类引用指向子类对象，此时编看左边是在说，
通过引用变量可以访问到的成员的范围，是由引用类型来决定的
a. 迄今为止，我们是怎么去访问一个对象？我们都是通过一个中间人即引用变量，间接访问堆上对象
b. 也就是说，只有通过引用变量，我才能访问到堆上的对象
举例：
1). 我们如果把对象，当成我们的一台电视机，对于电视机而言，我们只能使用，遥控器去操作电视机
2). 这也就意味着，遥控器提供了什么样的功能，那我们只能使用，遥控器提供的功能，操作电视机
此时即使电视机提供了很多功能可以使用，但是如果遥控器提供了，极其有限的功能
3). 这意味着，我们可以使用的电视机的功能，被遥控器给限制了
所以，回到java程序，访问对象的时候，引用变量，就是我们用来操作对象的"遥控器"，所以引用变量的类型
决定了，可以访问到的成员的范围。
2. 对于成员变量，运行看左边
一个对象 属性(成员变量) 和 行为，一个对象的属性(成员变量表示)，表示了一对象的外貌
在多态中，此时对于子类对象而言，把子类对象赋值给父类类型的引用，就相当于给子类对象
披上了一个父类类型马甲， 因此，该子类对象看起来，就是一个父类对象(外貌特征，
表现出的就应该是父类的外貌特征)
3. 对于成员方法的，运行(结果)看 右边(多态)
就是说对于成员方法而言，通过引用变量，实际访问到的行为(方法), 是由引用实际指向的对象来决定的
*/
public class Demo1Basic {
public static void main(String[] args) {
// 测试多态的效果
//testPoly();
// 测试多态成员的访问
//testMemberAccess();
// 父类类型的引用变量
PolyFather polyFather;
// 编译看左边
polyFather = new FirstPolySon();
// 通过父类引用，无法访问到，子类自己定义成员
//polyFather.son();
FirstPolySon first = new FirstPolySon();
// 通过子类应用，才能访问到，子类自己定义的成员
first.son();
// 总结一下，通过引用变量，到底能访问到哪些成员？
// 只和引用变量的类型有关系，而和引用变量所指向的实际类型
}
private static void testMemberAccess() {
// 多态的成员访问特征(成员变量，成员方法)
PolyFather polyFather;
polyFather = new FirstPolySon();
// 通过父类引用访问父类子类定义的同名成员变量值，访问的是父类定义的成员变量值
System.out.println(polyFather.value); // 100
// 多态效果
polyFather.testPolymorphism();
polyFather = new SecondPolySon();
// 通过父类引用访问父类子类定义的同名成员变量值，访问的是父类定义的成员变量值
System.out.println(polyFather.value); // 100
// 多态效果
polyFather.testPolymorphism();
}
private static void testPoly() {
// 父类引用指向子类对象
// 同一个引用变量
// PolyFather polyFather;
//
// // 多态的效果
// polyFather = new FirstPolySon();
// // 父类引用指向FirstPolySon子类对象
// polyFather.testPolymorphism();
//
// polyFather = new SecondPolySon();
// // 父类引用指向SecondPolySon子类对象
// polyFather.testPolymorphism();
PolyFather polyFather = new PolyFather();
testPolyMorphism(polyFather);
PolyFather firstPolySon = new FirstPolySon();
testPolyMorphism(firstPolySon);
PolyFather secondPolySon = new SecondPolySon();
testPolyMorphism(secondPolySon);
// 可以把一个子类类型的引用变量值 赋值 给父类类型的引用变量值
PolyFather father = secondPolySon;
}
/*
多态的效果
*/
public static void testPolyMorphism(PolyFather polyFather) {
polyFather.testPolymorphism();
}
}
class PolyFather {
int value = 100;
public void testPolymorphism() {
System.out.println("testPolymorphism in father ");
}
}
class FirstPolySon extends PolyFather {
int value = 200;
@Override
public void testPolymorphism() {
System.out.println("testPolymorphism in first son");
}
// 子类自己定义的方法，父类中未定义
public void son() { }
}
class SecondPolySon extends PolyFather {
int value = 300;
@Override
public void testPolymorphism() {
System.out.println("testPolymorphism in second son");
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
