面向对象day05（final；static final+常量；抽象方法；抽象类）

一、final:最终的，不可改变的

• final的单独利用率极低
  1.修饰变量:变量不能被改变
  2.修饰方法:方法不能被重写
  3.修饰类,类不能被继承

1）修饰变量：变量不能被改变

//演示final修饰变量
class Aoo{
	final int num = 5;
	void show(){
		//num = 55;	//编译错误:final的变量不能被改变
		//编译错误Cannot assign a value to final variable 无法为最终变量赋值
	}
}

2）修饰方法：方法不能被重写

//演示final修饰方法
class Boo{
	final void show(){
	}
class Coo extends Boo{
	//void show(){}	//编译错误，final修饰的方法不能被重写
}

3）修饰类：类不能被继承
（final的类不能被别人继承，但是它可以继承别人）

//演示final修饰类
final class Doo{}
//class Eoo extends Doo{}	//修饰错误，final的类不能被继承
class Foo{}
final class Goo extends Foo{}	//不能当老爸，但能当儿子

二、static final+常量（很常用）

是存数的
1）常量必须声明同时初始化(否则会编译错误)
2）通过类名点来访问，不能被改变
3）建议：常量名所有字母都大写，多个单词用_分隔
4）编译器在编译时会将常量直接替换成具体的值，效率高
5）何时用：数据永远不变，并且经常使用
6) static 和 final顺序可以交换

static final + 常量
集合了static 和 final 的特点

1. 常量需要列名打点来进行访问
2. 常量不能被改变

public class StaticFinalDemo {
    public static void main(String[] args) {
        System.out.println(Hoo.PI); //通过类名点来访问
        //Hoo.PI = 3.1415926; //编译错误，常量不能被改变

        //1)加载Ioo.class到方法区中
        //2)将静态变量num一并存储到方法区中
        //3)到方法区中获取num的值并输出
        System.out.println(Ioo.num);

        //编译器在编译时将常量直接替换为具体的值，效率高
        //相当于System.out.println(5);
        System.out.println(Ioo.COUNT);
    }
}

class Ioo{
    public static int num = 5; //静态变量
    public static final int COUNT = 5; //常量
}

class Hoo{
    public static final double PI = 3.14159;
    //public static final int NUM; //编译错误，常量必须声明同时初始化
}

补充:

• 常量在编译期编译时会将常量直接替换为具体的值，效率高，而且维护起来很方便

三、抽象方法

1）由abstract修饰
2）只有方法的定义，没有方法体,连{}都没有

四、抽象类

1. 由abstract修饰
2. 包含抽象方法的类必须是抽象类
3. 抽象类不能被实例化（new对象）
4. 抽象类是需要被继承的，派生类可以

• 重写所有抽象方法--------------变不完整为完整
• 也声明为抽象类------------------一般不这么做

5. abstract关键字不可以与private static final共用

抽象方法/抽象类的疑问？
抽象方法的意义是什么：当发生向上造型时，通过超类型的引用能点出来那个方法（就是能点出来，没了就点不出来了）
既然意义只在于点出来，那为什么不涉及为普通方法？
若设计为普通方法，则派生类可以重写也可以不重写，而设计为抽象方法，可以强制派生类必须重写————做了个标准，强制必须重写！
3）抽象类不能被实例化（new对象）
4）抽象类是需要被继承的，派生类：
①重写所有的抽象方法———— 变不完整为完整
②也声明为抽象类———— 一般不这么做

抽象类的意义：抽象类
1）封装共有的属性和行为——代码复用
2）为所有派生类统一的一个类型———向上造型———代码复用
3）可以包含抽象方法，为所有派生类提统一的入口（能点出来）
派生类的行为不同，但入口是一致的，同时相当于定义了一个标准。要求派生类必须重写

思考:为什么静态方法不能访问成员变量?
比如在Aoo类中写main方法,Aoo中有成员变量a = 3;
main是静态方法不能直接对成员变量和方法来进行访问的,因为是没有隐式的this,所以得需要new对象(即使也是在同一个类中也需要再main方法中new对象,然后对象打点来进行访问成员变量和成员方法)

补充：
1、设计规则：
1）将派生类所共有的属性和行为，抽到超类中————抽共性
2）派生类的行为都是一样的，则设计为普通方法
派生类的行为不一样，则设计为抽象方法
3）只要前面时数据类型，就能创建数组对象,我们在继承的时候，不能选择性继承

abstrac抽象类一定要作为超类的
final一定不能做超类的

左边小图标，o:表示重写