Java修饰符，抽象类

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不能同时修饰一个方法

Java修饰符，抽象类

猜你喜欢