静态"/>
访问控制修饰符、 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{ //--------------------演示privatevoid 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{ //跨包继承----------演示protectedvoid 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(){ //有隐式thisSystem.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张图片复制进去
更多推荐
访问控制修饰符、 final、静态
发布评论