final修饰符
final主要用法有以下四种:
一、用来修饰数据,包括成员变量和局部变量,该变量只能被赋值一次且它的值无法被改变。对于成员变量来讲,我们必须在声明时、构造方法或者初始化块中对它赋值;
1. public class FinalMemberVariables {
2. // final 修饰的实例变量
3. // 必须在非静态初始化块、声明该实例变量或构造器中指定初始值,
4.
5. //声明该实例变量指定初始值
6. final int INT_A=10;
7. //初始化块指定初始值
8. final int INT_B;
9. {
10.
11. INT_B=11;
12. }
13. final int INT_C;
14. //构造器中指定初始值
15. public FinalMemberVariables(){
16. INT_C=12;
17. }
18.
19. //final 修饰 类变量
20. //必须在静态初始化块中指定初始值或声明该类变量时指定初始值,
21. final static String STR_A="123";
22. final static String STR_B;
23. static{
24. STR_B="123456";
25. }
26. }
二、用来修饰局部变量,表示在变量的生存期中它的值不能被改变、
1. /**
2. * final 修饰 局部变量
3. * @author sxj
4. *
5. */
6. public class FinalLocalVariable {
7. //final修饰局部变量时,既可以在定义时指定默认值,也可以不指定默认值。
8. public static void main(String[] args) {
9.
10. //在定义时指定默认值
11. //不能再后面的代码中为变量赋值
12. final int INT_A=10;
13. //下面的赋值语句非法
14. //INT_A=12;
15.
16. //定义时不指定默认值
17. //可以在后面的代码中赋值一次
18. final String STR_A;
19. STR_A="123";
20. //下面的赋值语句非法
21. //STR_A="456";
22. }
23.
24.
25. public void test(final int num){
26. // 不能对final修饰的形参赋值
27. //num=10;
28. }
29. }
三、修饰方法,表示该方法无法被重写;
1. /**
2. * final 修饰的方法不能被重写Override
3. * @author sxj
4. *
5. */
6. public class FinalMethod {
7. public void print(){
8. System.out.println("FinalMethod---print方法");
9. }
10.
11. public final void finalPrint() {
12. System.out.println("FinalMethod--finalPrint方法");
13. }
14. }
15.
16.
17. class FinalMethodTow extends FinalMethod{
18. public void print(){
19. System.out.println("FinalMethodTow--print方法");
20. }
21.
22. //下面的代码有错误,无法重写final修饰的方法
23. // public void finalPrint() {
24. // System.out.println("FinalMethodTow--finalPrint方法");
25. // }
26. }
四、 修饰类,表示该类无法被继承。
1. /**
2. * final 修饰的类不能被继承
3. * @author sxj
4. *
5. */
6. public final class FinalClass {
7. int age=10;
8. }
9.
10. //classDemo2 无法继承 FinalClass
11. //class classDemo2 extends FinalClass{
12. //
13. //}
Java 抽象类
在面向对象的概念中,所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类。
抽象类除了不能实例化对象之外,类的其它功能依然存在,成员变量、成员方法、初始化块和构造方法和普通类一样。
由于抽象类不能实例化对象,所以抽象类必须被继承,才能被使用。
一、抽象方法
抽象方法只包含一个方法名,而没有方法体,使用abstract修饰。
格式:
- [修饰符] abstract 返回类型 方法名();
• 修饰符 (public protected private)三选一
二、示例代码
1. public abstract class Animal {
2.
3. //成员变量
4. protected int weight =0;
5.
6. {
7. System.out.println("初始化块");
8. }
9. //构造器
10. public Animal(){
11. System.out.println("Animal 的构造器");
12. }
13.
14. public Animal(int weight) {
15. this.weight=weight;
16. System.out.println("Animal 的构造器");
17. }
18.
19. // 定义一个普通方法 休息
20. public void sleep() {
21. System.out.println("休息");
22. }
23.
24.
25. //抽象方法 没有方法体
26. public abstract void running();
27.
28. public abstract String sayWeiget();
29. }
三、总结
- 抽象类必须使用abstract修饰符来修饰,
抽象方法也必须使用abstract修饰符来修饰,
抽象方法不能有方法体。 - 抽象类不能被实例化,
无法使用new关键字来调用抽象类的构造器创建抽象类的实例。 - 抽象类可以包含成员变量、
方法(普通方法和抽象方法都可以)、
构造器、初始化块、
内部类(接 口、枚举)5种成分。 - 抽象类的构造器不能用于创建实例,主要是用于被其子类调用。
- 抽象类中不一定包含抽象方法,但是有抽象方法的类必定是抽象类
- abstract static不能同时修饰一个方法