java static 获取当前类对象,Java笔记(七)——类和对象(下) static关键字 /访问限制符 /内部类 /栈 堆...

1 包

包可以说，就是目录，和磁盘上的目录是一一对应的。

导入包：

例如，scanner在使用时，我们就需要导入(import java.util.Scanner;),导入后才能正常使用。我们自己创建的包之间也可以这样导入，做法相同，都可以在输入时按Tab 键直接导入，或者用Alt + Enter 进行导入。

关于Scanner详细可看《Java : Scanner用法 干货 简明》。

2 static 关键字

2.1 static 修饰变量

如果类中的某个成员加上了static ，说明这个成员是一个 类属性/类方法；如果没有static ，说明这个成员是一个实例属性/实例方法。

例子：

public class Cat {

String name;

String gender;

public Cat(String name, String gender) {

this.name = name;

this.gender = gender; //实例属性

public static int n = 0; //类属性

this.eat("鱼");

}

public void eat(String food){

System.out.println(name + "正在吃" + food);

}

public class Main {

public static void main(String[] args) {

Cat cat = new Cat("糯米","公猫");

Cat cat2 = new Cat("粽子","母猫");

}

}

例子中，我们创建了两个Cat 类的对象，其中的name、和gender属性是实例属性，和对象相关。也就是不同的对象可以有不同的属性，一只是叫糯米的公猫，一只是叫粽子的母猫。

其中的n = 0 是类属性，和类相关和实例无关，我们可以通过 Cat.n 的方式访问并且修改n值。

Cat.n = 100;

System.out.println(Cat.n);

Cat 类就相当于模具，根据它会做出不同颜色、口味的猫抓点心，在这里是不同颜色、性别的猫。

2.2 static 修饰方法

public static void func(){

System.out.println("这是static 修饰的方法");

this.name; // 错误！！！

}

Cat.func();

我们写一个被static 修饰的方法，然后进行调用，注意通过类Cat 进行调用，不需要 Cat cat = new Cat (“糯米”，“公猫”) 这样的创建实例，它是被static修饰的类相关的方法，不需要实例也可以进行调用。

然后，注意在static修饰的静态方法中，不能使用this，this指向当前的实例，依托于实例，而static修饰的方法和实例无关，只和类有关。同理，无法在static 方法中访问非 static的变量的方法。

2.3 static 修饰代码块

static {

//静态代码块

//静态代码块，只在类加载的时候执行一次

System.out.println("这是静态代码块。");

}

{

System.out.println("这是普通代码块。");

}

Cat cat = new Cat("糯米","公猫");

Cat cat2 = new Cat("粽子","公猫");

静态代码块，只在程序启动的时候(类加载的时候)执行一次。通过上述例子，我们不难看出，静态代码块只执行了一次，而普通代码块执行了两次，因为创建了两个实例，创建几个实例，普通代码块就执行多少次。

3 访问限制符

前提条件：两个类，一个类A，一个调用类A的类B。

1、public：修饰的成员可以被外部的类随意访问。

public class A {

public int num = 0;

}

public class B {

public static void main(String[] args) {

A a = new A();

System.out.println(a.num); // 能正确访问

}

}

2、private：只能在A类中访问到

(一个成员，能是private，就尽量使用private)

public class A {

private int num = 0;

// 只能在A 类中使用

public static void main(String[] args) {

A a = new A();

System.out.println(a.num);

}

}

public class B {

public static void main(String[] args) {

A a = new A();

System.out.println(a.num); // 不能正确访问

}

}

3、default：在同一个包中就可以访问到

public class A {

int num = 0;

}

4、protected ：可以被同包的其他类访问，也可以被其他包的子类访问。

访问权限高低：

public > protected > default > private

4 内部类

一个类的定义在另一个类的里面。

1、普通内部类 / 成员内部类

public class A {

class Test{

public int num;

}

public void func() {

Test t = new Test();

t.num = 10;

}

public static void main(String[] args) {

Test test = new Test(); // 错误 ！！！

}

}

内部类Test 作为外部类A 的成员，它就要依托于 this 被引用，而在外部类A的static 修饰的方法是类相关的方法，没有this ，导致无法实例化。

2、静态内部类(内部类前用 static)

静态内部类不依赖外部类的 this，可以随意创建。

public class Main {

static class Test{ //加 static

public int num;

}

public void func() {

Test t = new Test();

t.num = 10;

}

public static void main(String[] args) {

Test test = new Test(); // 正确

}

}

3、匿名内部类(相对比较常用)

public class Main {

static class Test{ //加 static

public int num;

}

public void func() {

Test t = new Test();

t.num = 10;

}

public static void main(String[] args) {

//匿名内部类

A a = new A(){

//定义属性和方法

}；

}

}

匿名内部类，没有名字，是A类的子类(继承自A类)。

4、局部内部类

直接定义到方法的内部。

public class Main {

static void main(String[] args) {

Test test = new Test();

// 局部内部类

class Test{

}

}

}

5 类和对象的内存布局

1、前提条件：两个类，一个类Test，一个类Main，在类Main 中创建一个方法func2，该方法创建了Test 类的对象，并输出对象的num。在主方法中调用func2 。

public class Test {

public int num = 100;

}

public class Main {

public static void func2(){

Test t = new Test();

System.out.println(t.num);

}

public static void main(String[] args) {

func2();

}

}

首先，程序运行找主方法，主方法进栈，然后主方法中调用func2方法，func2方法进栈，在func2方法中创建了对象。

在创建对象的时候，新创建出来的对象在 堆 上面的 0x100位置，然后栈中的引用存着它的引用 t 0x100，引用指向堆上的实例。关于引用以及具体的入栈出栈《Java笔记(三) —— 方法调用/入栈 出栈 栈帧/重载问题》《Java笔记 (五)—— 引用类型》

2、前提条件：一个 Main 类，一个 B 类，一个 A 类。Main 类中有方法func2 创建了类 B 的对象，并在主函数中调用；类 B中创建了类 A 的实例作为成员；类 A 中创建了String 的实例 " hello " 作为成员 。

public class Main {

public static void func2(){

B b = new B();

}

public static void main(String[] args) {

func2();

}

}

public class B {

public A a = new A();

}

public class A {

tring str = "hello";

}

(1) 程序运行，从主方法开始，主方法进栈；

(2) 主方法调用func2方法,func2方法进栈；

(3) func2 方法根据类 B 创建了对象(实例)，创建出来的 B 的实例 b 在堆上的 0x100，栈帧中存放着实例的引用 b，该引用保存着实例在堆上的地址 0x100，指向在堆上的实例 b；而实例 b 中根据类 A 创建了实例，创建出来的 A 的实例 a 在堆上的 0x200，实例 b 中存放着实例 a 的地址0x200；

(4) 实例 a 创建了 String 的实例，创建出来的实例 str 在堆上的0x300，实例 a 中存放着 String 实例的地址 0x300；

(5) 堆上的0x300 放着创建的 String 的实例 " hello "。

3、上面两个例子讲了栈和堆，还有一个很重要的区域：方法区。方法区里存着的是一个一个 “ 类相关的信息 ”(每个类的方法的二进制的指令也是在这里)

(1) 如果属性是一个实例属性，那么不在方法区，是跟着实例走的，实例一般在 堆上；

(2)如果属性是一个类属性，那么就在 方法区；

(3)对于方法来说，不管是加 static 还是不加，对应的内容都在方法区。

前提条件：一个Main 类，一个 A 类，Main 类的主方法创建了类 A 的实例。

public class Main {

public static void main(String[] args) {

A a = new A();

}

}

public class A {

static public int num = 100;

static public String str = "hello";

public int num2 = 200;

public void func(){

//

}

}

main方法入口，main方法进栈，然后main方法创建了实例 a，该实例的地址存在栈帧的引用 a 中 0x100，实例存在堆上，num2 = 200为实例属性跟着实例走，所以在堆 上；A 类中的方法func 存在方法区中； A 类中的其他属性因为被 static 修饰为类属性，所以在方法区中，但注意static 修饰的String ，是将引用 str 0x200 存在方法区，由String 创建的实例str 在堆上。

看明白了会发现，有点意思，冲冲冲~