fianl关键字和static关键字

final关键字

1.概念：

继承的出现提高了代码的复用性，并方便开发。但随之也有问题，有些类在描述完之后，不想被继承，或者有些类中的部分方法功能是固定的，不想让子类重写。可是当子类继承了这些特殊类之后，就可以对其中的方法进行重写，那怎么解决呢？

要解决上述的这些问题，需要使用到一个关键字final，final的意思为最终，不可变。final是个修饰符，它可以用来修饰类，类的成员，以及局部变量。不能修饰构造方法。

2.final的特点：

1.final 修饰类不可以被继承，但是可以继承其他的类（相当于太监，只能当儿子不能当爹）

package com.oracle.demo04;
//final修饰类(太监类,没有子类)
//不能被继承，但可以继承其他类
public final class Fu extends Object{

}

2.final 修饰的方法不可以被子类重写，但是父类中没有被final修饰的方法，子类重写后可以加final

package com.oracle.demo04;
//被final修饰的方法
public class Fu2 {
    public final void xiuche(){
        System.out.println("失传的手艺");
    }
    public void maiche(){
        System.out.println("这是祖传的卖车手艺");
    }
}
package com.oracle.demo04;

public class Zi extends Fu2{
    //Cannot override the final method from Fu2
    /*public final void xiuche(){

    }*/
    public final void maiche(){

    }
}

3.final 修饰的变量成为常量，这些变量只能成为一次，而且终身不变

final int i = 20;
i = 30; //赋值报错，final修饰的变量只能赋值一次

4.引用类型的变量值为对象地址值，地址值不能更改，但是地址内的对象属性至可以修改

final Person p = new Person();//p获得一个地址
Person p2 = new Person();//p2获得一个地址
p = p2; //final修饰的变量p，所记录的地址值不能改变，所以会报错
p.name = "小明";//可以更改p对象中name属性值

5.修饰成员变量，需要在创建对象前赋值，否则报错。(当没有显式赋值时，多个构造方法的均需要为其赋值。)

package com.oracle.demo04;
//被final修饰的成员变量没有系统默认初始值
public class Zi3 {
    //直接赋值
    //final String name="小红";
    //通过构造方法赋值
    final String name;
    public Zi3(){
        name="小红";
    }
}

static 关键字

static概念：静态修饰符，一般用来修饰类中的成员，可以不创建对象直接调用方法

static 特点：

1.被static修饰的成员属于类，不属于类中的某个对象

    class Demo {
    public static int num = 100;
}

class Test {
    public static void main(String[] args) {
        Demo d1 = new Demo();
        Demo d2 = new Demo();
        d1.num = 200;
        System.out.println(d1.num); //结果为200
        System.out.println(d2.num); //结果为200
    }
}

2.被static 修饰的成员可以直接通过类名来进行访问

class Demo {
    //静态成员变量
    public static int num = 100;
    //静态方法
    public static void method(){
        System.out.println("静态方法");
    }
}
class Test {
    public static void main(String[] args) {
        System.out.println(Demo.num);
        Demo.method();
    }
}

3.static 的注意事项：

静态的内容是优先于对象存在，只能访问静态，不能使用this/super，静态修饰的内容存在于静态区

class Demo {
    //成员变量
    public int num = 100;
    //静态方法
    public static void method(){
        //this.num; 不能使用this/super。
        System.out.println(this.num);
    }
}

同一个类中  静态成员只能访问静态成员

class Demo {
    //成员变量
    public int num = 100;
    //静态成员变量
    public static int count = 200;
    //静态方法
    public static void method(){
        //System.out.println(num); 静态方法中，只能访问静态成员变量或静态成员方法
        System.out.println(count);
    }
}

main方法只是一个程序的入口，可以写在任意的一个类中

多态方法中，编译看等号的左边，父类有的话，编译成功，父类没有的话编译失败

运行静态方法，运行父类中的静态方法

运行非静态方法，运行的是子类中重写的方法

成员变量，编译和运行的都是父类

package com.oracle.demo05;

public class student {
    String name;
    int age;
    static String schoolName;
}

package com.oracle.demo05;

public class test {
    public static void main(String[] args) {
        student s=new student();
        s.name="小红";
        s.schoolName="北京大学";
        student s2=new student();
        s2.name="小明";
        s2.schoolName="清华大学";
        System.out.println(s.schoolName+"..."+s2.schoolName);
    }
}

原文地址：https://www.cnblogs.com/mr171733/p/9700190.html