访问控制修饰符：--------------保护数据的安全(隐藏数据、暴露行为)，实现封装
-
public：公开的，任何类
-
private：私有的，本类
-
protected：受保护的，本类、派生类、同包类
-
默认的：什么也不写，本类、同包类--------------------------java不建议
注意：
-
访问权限由低到高依次为：private<默认的<protected<public
-
类的访问权限只能是public或默认的，类中成员的访问权限如上4种都可以。
-
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; //编译错误
}
}final：最终的、不能改变的------------单独应用几率低
-
修饰变量：变量不能被改变
//演示final修饰变量
class Eoo{
final int num = 5;
void show(){
//num = 55; //编译错误，final的变量不能被改变
}
}修饰方法：方法不能被重写
class Foo{
final void show(){}
void test(){}
}
class Goo extends Foo{
//void show(){} //编译错误，final的方法不能被重写
void test(){}
}修饰类：类不能被继承
final class Hoo{}
//class Ioo extends Hoo{} //编译错误，final的类不能被继承
class Joo{}
final class Koo extends Joo{} //正确，不能当老爸，但能当儿子static：静态的
静态变量：
-
由static修饰
-
属于类，存储在方法区中，只有一份
-
常常通过类名点来访问
-
何时用：对象所共享的数据
public class StaticVar {
int a; //实例变量
static int b; //静态变量
StaticVar(){
a++;
b++;
}
void show(){
System.out.println("a="+a+"，b="+b);
}
}
public class StaticDemo {
public static void main(String[] args) {
StaticVar o1 = new StaticVar();
o1.show();
StaticVar o2 = new StaticVar();
o2.show();
StaticVar o3 = new StaticVar();
o3.show();
System.out.println(StaticVar.b); //常常通过类名点来访问
}
}
静态块：
-
由static修饰
-
属于类，在类被加载期间自动执行，一个类只被加载一次，所以静态块也只执行一次
-
何时用：初始化/加载静态资源/静态变量
public class StaticBlock {
static{
System.out.println("静态块");
}
StaticBlock(){
System.out.println("构造方法");
}
}
public class StaticDemo {
public static void main(String[] args) {
StaticBlock o4 = new StaticBlock(); //加载类时自动执行静态块
StaticBlock o5 = new StaticBlock();
StaticBlock o6 = new StaticBlock();
}
}静态方法：
-
由static修饰
-
属于类，存储在方法区中，只有一份
-
常常通过类名点来访问
-
静态方法中没有隐式this传递，所以静态方法中不能直接访问实例成员(实例变量/实例方法)
-
何时用：方法的操作与对象无关(不需要访问对象的属性/行为)
public class StaticMethod {
int a; //实例变量(对象来访问)--------------属于对象的
static int b; //静态变量(类名来访问)-------属于类的
//方法的操作与对象无关(不需要访问对象的属性/行为)
//在say()中需要访问对象的属性a，所以认为say的操作与对象有关，不适合设计为静态方法
void say(){
System.out.println(a);
}
//在plus()中不需要访问对象的属性/行为，所以认为plus的操作与对象无关，可以设计为静态方法
static int plus(int num1,int num2){
int num = num1+num2;
return num;
}
void show(){ //有隐式this
System.out.println(this.a);
System.out.println(StaticMethod.b);
}
static void test(){ //没有隐式this
//静态方法中没有隐式this传递
//没有this就意味着没有对象
//而实例变量a必须通过对象来访问
//所以如下语句发生编译错误
//System.out.println(a); //编译错误，静态方法中不能直接访问实例成员
System.out.println(StaticMethod.b);
}
}
public class StaticDemo {
public static void main(String[] args) {
StaticMethod.test(); //常常通过类名点来访问
}
}static final常量：应用率高
-
必须声明同时初始化
-
常常通过类名点来访问，不能被改变
-
建议：常量名所有字母都大写，多个单词之间用_分隔
-
编译器在编译时，会将常量直接替换为具体的数，效率高
-
何时用：在程序运行过程中数据永远不变，并且经常使用
public class StaticFinalDemo {
public static void main(String[] args) {
System.out.println(Loo.PI); //常常通过类名点来访问
//Loo.PI = 3.1415926; //编译错误，常量不能被改变
//1)加载Loo.class到方法区中
//2)静态变量num一并存储到方法区中
//3)到方法区中获取num的值并输出
System.out.println(Loo.num);
//编译器在编译时会将常量直接替换为具体的数，效率高
//相当于System.out.println(5);
System.out.println(Loo.COUNT);
}
}
class Loo{
public static int num = 5; //静态变量
public static final int COUNT = 5; //常量(静态常量)
public static final double PI = 3.14159;
//public static final int NUM; //编译错误，常量必须声明同时初始化枚举：
-
是一种引用数据类型
-
特点：枚举类型的对象数目是固定的，常常用于定义一组常量
-
所有枚举都继承自Enum类，其中提供了一组方法供我们使用
-
枚举的构造方法都是私有的
public enum Season {
//表示Season的固定的4个对象，都是常量
//public static final Season SPRING = new Season("春天","暖和");
SPRING("春天","暖和"),
SUMMER("夏天","热"),
AUTUMN("秋天","凉爽"),
WINTER("冬天","冷");
private String seasonName;
private String seasonDesc;
Season(String seasonName, String seasonDesc) {
this.seasonName = seasonName;
this.seasonDesc = seasonDesc;
}
public String getSeasonName() {
return seasonName;
}
public void setSeasonName(String seasonName) {
this.seasonName = seasonName;
}
public String getSeasonDesc() {
return seasonDesc;
}
public void setSeasonDesc(String seasonDesc) {
this.seasonDesc = seasonDesc;
}
}
public class EnumDemo {
public static void main(String[] args) {
Season[] seasons = Season.values(); //获取所有枚举的对象
for(int i=0;i<seasons.length;i++){
System.out.println(seasons[i]); //输出4个枚举对象(SPRING、SUMMBER、AUTUMN、WINTER)
System.out.println(seasons[i].getSeasonName()); //输出枚举的名字属性
System.out.println(seasons[i].getSeasonDesc()); //输出枚举的描述属性
}
Season s = Season.WINTER; //获取SPRING对象
System.out.println(s.getSeasonName()+"，"+s.getSeasonDesc());
switch (s){
case SPRING:
System.out.println("天气"+s.getSeasonDesc()+"，放风筝去喽!");
break;
case SUMMER:
System.out.println("天气"+s.getSeasonDesc()+"，游戏去喽!");
break;
case AUTUMN:
System.out.println("天气"+s.getSeasonDesc()+"摘苹果去喽!");
break;
case WINTER:
System.out.println("天气"+s.getSeasonDesc()+"打雪仗去喽!");
break;
}
}
}注:
-
数据(成员变量)私有化(private)、行为(方法)大部分公开化(public)
-
getter/setter：行业标准
-
重写的注意事项：派生类中重写方法的访问权限必须大于或等于超类方法的
-
匿名内部类中不能修饰外面局部变量的值，在匿名内部类该变量会默认为final的
-
成员变量分两种：
-
实例变量：没有static修饰，属于对象的，存储在堆中，有几个对象就有几份，通过引用/对象打点来访问
-
静态变量：有static修饰，属于类的，存储在方法区中，只有一份，通过类名打点来访问
-
- 工具类：
1)Math:数学工具类，里面封装了很多数学相关的静态方法/工具
2)Arrays:数组工具类，里面封装了很多数组相关的静态方法/工具
为什么要自己写构造方法？
1. 创建对象同时为属性赋值；
2.限制对象的创建过程（或者说不允许随意创建对象）；
3.强制要求传入某些数据。
328
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
