静态方法与访问修饰

编程入门行业动态更新时间:2024-10-24 06:25:15

静态方法与访问修饰

笔记：

package和import：
- package：声明包
  - 作用：避免类的命名冲突
  - 同包中的类不能同名，不同包中的类可以同名
  - 类的全称：包名.类名，包名常常有层次结构
  - 建议：包名所有字母都小写
- import：导入类
  - 同包中的类可以直接访问的，不同包中的类不能直接访问，若想访问：
    - 先import导入类，再使用类----------建议
    - 类的全称------------------------------------太繁琐，不建议

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

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

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; //编译错误}
}

final：最终的、不可改变的-------------单独应用率低，了解即可

修饰变量：变量不能被改变
修饰方法：方法不能被重写
修饰类：类不能被继承

//演示final修饰变量
class Eoo{final int num = 5;void show(){//num = 8; //编译错误，final的变量不能被改变}
}//演示final修饰方法
class Foo{final void show(){}void test(){}
}
class Goo extends Foo{//void show(){} //编译错误，final的方法不能被重写void test(){}
}//演示final修饰类
final class Hoo{}
//class Ioo extends Hoo{} //编译错误，final的类不能被继承
class Joo{}
final class Koo extends Joo{} //不能当老爸，但能当儿子

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) {int a = Noo.plus(5,6); //常常通过类名点来访问}
}
//演示静态方法
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; //实例变量(属于对象，描述对象的属性)//在show()中访问的对象的属性a，意味着与对象有关，所以不能设计为静态方法void show(){System.out.println(a);}//在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();Poo o6 = new Poo();}
}
//演示静态块
class Poo{static{System.out.println("静态块");}Poo(){System.out.println("构造方法");}
}

精华笔记：

package和import：
- package：声明包
  - 作用：避免类的命名冲突
  - 同包中的类不能同名，不同包中的类可以同名
  - 类的全称：包名.类名，包名常常有层次结构
  - 建议：包名所有字母都小写
- import：导入类
  - 同包中的类可以直接访问的，不同包中的类不能直接访问，若想访问：
    - 先import导入类，再使用类----------建议
    - 类的全称------------------------------------太繁琐，不建议
访问控制修饰符：---------------------保护数据的安全
- public：公开的，任何类
- private：私有的，本类
- protected：受保护的，本类、派生类、同包类
- 默认的：什么也不写，本类、同包类---------------------java不建议
  说明：
  1. 类的访问权限只能是public或默认的
  2. 类中成员的访问权限如上4种都可以
  3. 访问权限由大到小：public>protected>默认的>private
final：最终的、不可改变的-------------单独应用率低，了解即可
- 修饰变量：变量不能被改变
- 修饰方法：方法不能被重写
- 修饰类：类不能被继承
static：静态的
- 静态变量：
  - 由static修饰
  - 属于类，存储在方法区中，只有一份
  - 常常通过类名点来访问
  - 何时用：所有对象所共享的数据(图片、音频、视频等)
- 静态方法：
  - 由static修饰
  - 属于类，存储在方法区中，只有一份
  - 常常通过类名点来访问
  - 静态方法中没有隐式this传递，所以不能直接访问实例成员
  - 何时用：方法的操作与对象无关(不需要访问对象的数据)
- 静态块：
  - 由static修饰
  - 属于类，在类被加载时自动执行，一个类只被加载一次，所以静态块只执行一次
  - 何时用：初始化/加载静态资源(图片、音频、视频等)

补充：

访问权限常规使用规则：
- 实例变量一般都private
- 方法绝大部分情况都是public的，但是若某方法只是我自己用，也是可以private的
- 静态的一般都是public
成员变量分两种：
- 实例变量：没有static修饰，属于对象的，存储在堆中，有几个对象就有几份
  
  通过引用打点来访问
- 静态变量：由static修饰，属于类的，存储在方法区中，只有一份
  
  通过类名打点来访问
内存管理：由JVM管理
- 堆：new出来的对象(包括实例变量)
- 栈：局部变量(包括方法的参数)
- 方法区：.class字节码文件(包括静态变量、所有方法)
给成员变量赋值规则：
- 静态变量，一般在静态块中初始化
- 实例变量，一般在构造方法中初始化