修饰词

三大修饰字

abstarct

abstract意为抽象的，可以用来描述抽象的事物和抽象的行为，在程序中被abstract修饰的类和方法称为抽象类、抽象方法

抽象类本质还是类，作用还是描述一类事物，只是这类事物比较抽象（某些行为比较抽象，不够具体，很难实现）

抽象类的成分

定义属性

定义构造器

定义实例方法

......

普通类可以定义的抽象类都可以定义，只是不能实例化本身

抽象类可以没有抽象方法，有抽象方法的类必须是抽象类

抽象方法的子类没有重写实现抽象方法（可以为空，即方法体为空），则子类必须被定义为抽象方法

抽象类的意义

可作为父类使用，提取共性的属性和行为

可以建立多态使用方式

抽象方法

一般在父类中方，这个方法无法给出具体的实现

抽象方法使用abstract修饰，没有方法体

​

public  abstract    class Animal { //定义抽象类
    private String name;
    private int age;

    public Animal() {
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //省略gets/sets
 	
    //定义抽象方法
    public abstract  void eat(); 

}
public class Dog extends Animal {
    public Dog() {
    }
    public Dog(String name, int age) {
         super(name, age);
    }
    //重写抽象方法
    @Override
    public void eat() {           
        System.out.println("狗吃骨头......");
    }
}

public class TestAnimal {
    public static void main(String[] args) {
        Animal animal = new Dog("旺财",10);
        animal.eat();
        System.out.println(animal.getName()+animal.getAge());
    }
}

static

特点

static是一个关键词，可以修饰属性和方法，被static修饰的属性和方法称为 静态属性、静态方法，区别于实例属性，静态属性只有一份，通过类名便可访问，同理静态方法也是通过类名直接调用

实例属性是每个对象各自持有的独立空间，对象单方面修改，不会影响其他对象

静态属性是整个类共同持有一份，任何对象修改，都会影响其他对象

总之，静态属性和静态方法不依赖对象，而是依赖类

class Foo{
    
    public static int num; //静态属性
    public static foo(){   //静态方法
       
    }
}

class Test{
    public static void main(String[] args){
        Foo.num=100; //通过类名 访问静态属性 
        Foo.foo();   //通过类名 访问静态方法
    }
}

静态方法

​ 可以访问静态属性、静态方法，不可访问实例属性和实例方法，以及实例相关的this、super关键字

class Foo{
    public int age;        //实例属性
   
    public static int num; //静态属性
    
    
    public void   bar(){   //实例方法
         sout( age );  //可以
         sout( num );  //可以
    }
    public static foo(){   //静态方法
         //sout( age ); // 不可
         //bar()        // 不可
         //sout(this)   // 不可
         //sout(super)  // 不可 
         sout( num );
    }
}

静态代码块

用于初始化静态属性的代码块，类加载时执行，一个类只能加载一次所以代码块也只执行一次，关于静态属性的初始化，根据赋值语句的先后顺序来判断

一个类加载后，在准备阶段开辟了静态属性的空间，但是不是立即就赋值的，

​ static int age =10 ; 即便是写成一句话，也是分为两个阶段。

​ 准备 ： int age =0

​ 初始化： age =10;

final

意为最终的、不可变的，表示不可更改的意思，可以修饰类、方法

属性（变量）

修饰类，表示最终类

final class Animal{

}

class Dog extends Animal{ //Error 会报错


}

​ 使用final控制一个类不可继承，String就是final修饰的最终类

修饰方法，表示最终的方法

class Animal{
    public  final   void eat(){
        System.out.println("不知道怎么吃.....");
    }
}

class Cat extends  Animal{
    @Override
    public void eat() { //Error 会报错
        System.out.println("重写......");
    }
}

final修饰方法，表示最终的方法，此方法不可被重写

修饰变量（属性）

class Animal{

    final  int  leg ;

    public Animal() {
        leg=100;
    }

    public Animal(String name){

        leg = 1000;
    }
}

final修饰属性，一定要初始化，赋值一次，赋值之后不可改变

public static void main(String[] args){
     final int a = 10;
     a = 100; //Error 会报错
}

修饰局部变量，只能赋值一次

abstract 可不可以与 private static final 关键字连用

不可以

1. 抽象方法，只有方法头，没有方法体，抽象方法无需实现，抽象方法的意义在于子类的实现，private意义在于其他类不能直接调用它已经实现的方法，private修饰后为私有，子类不能继承，自然不能使用
2. final用于类名前，表示类不可被继承，final用于变量前，表示它只能是赋值一的值，如果初始化了那就是常量，也不可能被改变，和abstract搭配， final不能被重写，不能被abstract修饰的实现类重写
3. static修饰的是静态方法，可以直接被类调用，而被abstract修饰的只有方法名，没有方法体，不能被直接调用，所以不能同时修饰一个方法

标签：修饰词,public,static,修饰,方法,final,属性
来源： https://www.cnblogs.com/ShangStudyJava/p/14746362.html