访问控制修饰符、 final、静态

-作用：避免类的命名冲突

-同包中的类不能同名，但不同包中的类可以同名

-类的全称：包名。类名，包名尝尝有层次结构

-建议：包名所有字母都小写

import:导入类

-同包中的类可以直接访问

-不同包中的类不能直接访问，若想访问：

        -先import导入类再使用类------------建议

        -类的全称---------------------------------------太繁琐，不建议

2.访问控制修饰符：------------------------保护数据的安全

 -public：公开的，任何类

-private：私有的，本类

-protected：受保护的，本类、派生类、同胞类

-default   默认的： 什么也不写，本类、同胞类

        >说明：

        >

        >1.java不建议默认访问权限

        >2.类的访问权限只能是public或默认的，类中成员的访问权限如上4种都可以

        >3.访问权限由小到大依次为：private<默认的<protected<public

//访问控制符的演示

package ooday05;
//访问控制修饰符的演示
public class Aoo {
    public int a;    //任何类
    protected int b; //本类、派生类、同包类
    int c;           //本类、同包类
    private int d;   //本类

    void show(){
        a = 1;
        b = 2;
        c = 3;
        d = 4;
    }
}
class Boo{ //--------------------演示private
    void show(){
        Aoo o = new Aoo();
        o.a = 1;
        o.b = 2;
        o.c = 3;
        //o.d = 4; //编译错误
    }
}

package ooday05_vis;
import ooday05.Aoo;
public class Coo { //----------------演示同包的
    void show(){
        Aoo o = new Aoo();
        o.a = 1;
        //o.b = 2; //编译错误
        //o.c = 3; //编译错误
        //o.d = 4; //编译错误
    }
}
class Doo extends Aoo{ //跨包继承----------演示protected
    void show(){
        a = 1;
        b = 2;
        //c = 3; //编译错误
        //d = 4; //编译错误
    }
}

3.final：最终的、不能改变的-------------------单独应用几率低

-修饰变量：变量不能被改变

-修饰方法：方法不能被重写

-修饰类：类不能被继承

package ooday05_vis;
//演示final修饰变量
class Eoo{
    final int a = 5;
    void test(){
        //a = 55; //编译错误，final的变量不能被改变
    }
}

//演示final修饰方法
class Foo{
    final void show(){}
}
class Goo extends Foo{
    //void show(){} //编译错误，final的方法不能被重写
}

//演示final修饰类
final class Hoo{}
//class Ioo extends Hoo{} //编译错误，final的类不能被继承
class Joo{}
final class Koo extends Joo{} //正确，不能当老爸，但能当儿子

4.static：静态的

-静态变量：

 -由static修饰

 -属于类，存储在方法区中，一份

 -常常通过类名点来访问

 -何时用：所有对象所共享的数据（图片、音频、视频等）

public class StaticDemo {
    public static void main(String[] args) {
        Loo o1 = new Loo();
        o1.show();
        Loo o2 = new Loo();
        o2.show();
        Loo o3 = new Loo();
        o3.show();
        System.out.println(Loo.b); //常常通过类名点来访问
    }
}
//演示静态变量
class Loo{
    int a;
    static int b;
    Loo(){
        a++;
        b++;
    }
    void show(){
        System.out.println("a="+a+"，b="+b);
    }
}

-静态方法：

  -由static修饰

  -属于类，存储在方法区中，一份

  -常常通过类名点来访问

  -静态方法中没有隐式this传递，所以不能直接访问实例成员，只能直接访问静态成员

  -何时用：方法的操作与对象无关------方法中不需要访问对象的属性或行为

public class StaticDemo {
    public static void main(String[] args) {
        Moo.test();
    }
}

//演示静态方法
class Moo{
    int a; //实例变量(对象点来访问)
    static int b; //静态变量(类名点来访问)

    void show(){ //有隐式this
        System.out.println(this.a);
        System.out.println(Moo.b);
    }
    static void test(){ //没有隐式this
        //静态方法中没有隐式this传递
        //没有this就意味着没有对象
        //而实例变量a必须通过对象点来访问
        //所以如下代码发生编译错误
        //System.out.println(a); //编译错误
        System.out.println(Moo.b);
    }
}

//演示静态方法在何时用
class Noo{
    int a; //对象的属性a

    //在show()中用到了对象的属性a，意味着show()方法与对象有关，所以不能设计为静态方法
    void show(){
        System.out.println(a);
    }
    //在plus()中没有用到对象的属性，意味着plus()方法与对象无关，所以可以设计为静态方法
    static int plus(int num1,int num2){
        int num = num1+num2;
        return num;
    }
}

-静态块：

   -由static修饰

    -属于类，在类被加载时自动执行，因为一个类只被加载一次，所以静态块也只执行一次

    -何时用：加载/初始化静态资源（图片、音频、视频等）

public class StaticDemo {
    public static void main(String[] args) {
        Poo o4 = new Poo();
        Poo o5 = new Poo();
    }
}

//演示静态块
class Poo{
    static{
        System.out.println("静态块");
    }
    Poo(){
        System.out.println("构造方法");
    }
}

 

精华笔记：
1.package和import：

        1.package：声明包
                1.避免类的命名冲突
                2.同包中的类不能同名，但不同包中的类可以同名
                3.类的全称：包名.类名
                4.包名常常用层次结构，建议所有字母都小写
        2.import：导入类
                1.同包中的类可以直接访问
                  不同包中的类不能直接访问，若想访问：
                        1.先import声明类，再访问类------建议
                        2.类的全称-----------------------------太繁琐，不建议
2.访问控制修饰符：--------------------------保证数据的安全

        1.public：公开的，任何类
        2.private：私有的，本类
        3.protected：受保护的，本类、派生类、同包类
        4.默认的：什么也不写，本类、同包类
说明：
- 类的访问权限只能是public或默认的
- 类中成员的访问权限如上4种都可以
- 访问权限由高到低依次为：public>protected>默认的>private

3.final：最终的、不可改变的------------单独应用几率极低

        1.修饰变量：变量不能被改变
        2.修饰方法：方法不能被重写
        3.修饰类：类不能被继承
4.static：静态的

        1.静态变量：
                1.由static修饰
                2.属于类，存储在方法区中，只有一份
                3.常常通过类名点来访问
                4.何时用：所有对象所共享的数据(图片、音频、视频等)
        2.静态方法：
                1.由static修饰
                2.属于类，存储在方法区中，只有一份
                3.常常通过类名点来访问
                4.静态方法中没有隐式this传递，不能直接访问实例成员
                5.何时用：方法的操作与对象无关
        3.静态块：
                1.由static修饰
                2.属于类，在类被加载期间自动执行，一个类只被加载一次，所以静态块只执行一次
                3.何时用：加载/初始化静态资源(图片、音频、视频等)

 

 

##补充：
        1.数据(成员变量)私有化(private)，行为(方法)大部分公开化(public)
        2.成员变量分两种：
                1.实例变量：没有static修饰，属于对象的，存储在堆中，有几个对象就有几份
                   通过引用(对象)点来访问
                2.静态变量：由static修饰，属于类的，存储在方法区中，只有一份
                   通过类名点来访问
        3.内存管理：由JVM来管理
                1.堆：new出来的对象(包括实例变量)
                2.栈：局部变量(包括方法的参数)
                3.方法区：.class字节码文件(包括静态变量、所有方法)
        4.图片存储位置：点项目名称submarine，右键New一个Directory，命名为img，将8张图片复制进去