权限修饰符和状态修饰符final和static的应用--java基础学习

case1包

package case1;
public class Demo {
    public static void main(String[] args) {
        Fu f= new Fu();
        f.show2();
        f.show3();
        f.show4();
    }
}

package case1;
public class Fu {
    private void show1(){
        System.out.println("private");
    }
    void show2(){
        System.out.println("默认");
    }
    protected void show3(){
        System.out.println("protected");
    }
    public void show4(){
        System.out.println("public");
    }
    public static void main(String[] args){
        Fu f = new Fu();
        f.show1();
        f.show2();
        f.show3();
        f.show4();
    }
}

public class Zi extends Fu{
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show2();
        z.show3();
        z.show4();
    }
}

case2包

package case2;
import case1;
public class Demo {
    public static void main(String[] args) {
        Fu f = new Fu;
        f.show4();
    }
}

package case2;
import case1;
public class Zi extends Fu{
    public static void main(String[] args){
        Zi z = new Zi();
        z.show3();
        z.show4();
    }
}

总结

修饰符	同一个类中	同一个包中子类无关类	不同包的子类	不同包的无关类
private	√
默认	√	√
protected	√	√	√
public	√	√	√	√

final 修饰方法、修饰变量、修饰变量

/***状态修饰符
 *  final(最终态)   final关键字是最终的意思，可以修饰成员方法，成员变量，类；
 * final关键字是最终的意思，可以修饰成员方法，成员变量，类
 * final修饰的特点
 *      修饰方法:表明该方法是最终方法，不能被重写
 *      修饰变量:表明该变量是常量，不能再次被赋值
 *      修饰类:表明该类是最终类，不能被继承
 *
 *  static(静态)
 * */
public class Demo {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.method();
        z.show();
    }
}

/*
public class Fu {
    public final void method(){
        System.out.println("Fu method");
    }
}*/
public final class Fu{
    public final void method(){
        System.out.println("Fu method");
    }
}

package itheima11;

public class Zi extends Fu {
    //@Override
    //public void method(){
    //    System.out.println("Zi method");
    //}
    public final int age = 20;
    public void show(){
    //    age = 100;
        System.out.println(age);
    }
}

final 修饰局部变量

/***
 * final修饰局部变量:
 * 变量是基本类型: final修饰指的是基本类型的数据值不能发生改变
 * 变量是引用类型: final修饰指的是引用类型的地址值不能发生改变，但是地址里面的内容是可以发生改变的

 *
* */
public class FinalDemo {
    public static void main(String[] args){
        final int age = 20;
         //age = 100;
        System.out.println(age);

        final Student s = new Student();
        s.age = 100;
        System.out.println(s.age);

        //s = new Student();
    }
}

public class Student {
    public int age = 20;
}

static 修饰的特点

/***
 * static 关键字是静态的意思，可以修饰成员方法、成员变量
*  static修饰的特点
 *      被类的所有对象共享
 *          这也是我们判断是否使用静态关键字的条件
 *      可以通过类名调用
 *            当然，也可以通过对象名调用
 *            推荐使用类名调用
 **/
public class StaticDemo {
    public static void main(String[] args) {
        Student.university = "大学";
        Student s1 = new Student();
        s1.name = "林青霞";
        s1.age = 30;
        //s1.university = "大学";
        s1.show();

        Student s2 = new Student();
        s2.name = "风清扬";
        s2.age = 33;
        //s2.university = "大学";
        s2.show();
    }
}

public class Student {
    public String name;
    public int age;
    static public String university;

    public void show(){
        System.out.println(name+","+age+","+university);
    }
}

static 成员访问方法

/***
 * static
 * 非静态的成员方法
        能访问静态的成员变量
        能访问非静态的成员变量
        能访问静态的成员方法
        能访问非静态的成员方法
 * 静态的成员方法
        能访问静态的成员变量
        能访问静态的成员方法
 总结成一句话就是:静态成员方法只能访问静态成员
 *
* */
public class Student {
    private String name = "林青霞";
    private static String university = "大学";
    public void show1(){

    }
    public void show2(){
        System.out.println(name);
        System.out.println(university);
        show1();
        show3();
    }
    public static void show3(){

    }
    public static void show4(){
        //System.out.println(name);
        System.out.println(university);
        //show1();
        show3();
    }
}