首页 > 其他分享> 文章详细

修饰词

2021-05-08 20:33:27 阅读：125 来源： 互联网

标签：修饰词 public static 修饰方法 final 属性

三大修饰字

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 关键字连用

不可以

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

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

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

修饰词