控制对类成员的访问

1.控制对类成员的访问：使用访问权限修饰符 private、默认(包级私有的)、protected、public

1.1 应用于class的访问权限修饰符：默认的、public

1.1.1 一个Java源文件中，可以有多个class类，但是只能有一个是public的

1.1.2 源文件的名称，必须与public类的名称相同

1.2 应用于成员变量的访问权限修饰符：private、默认(包级私有的)、protected、public
1.3 应用于成员方法的访问权限修饰符：private、默认(包级私有的)、protected、public
1.4 应用于构造器的访问权限修饰符：private、默认(包级私有的)、protected、public

//学生类Student
class Student{
	private String name;//类级私有
	static String subject;
         
	public Student(){}

	public void setName(String aa){
		name = aa;
	}

	public static void tellYouMySubject(){
		System.out.println("我叫" + name + ",我的专业是" + subject);
	}
}

public class Demo2{
	public static void main(String[] args){
		Student stu01 = new Student();
		stu01.subject = "计科系";
		
//		stu.name = "张三";
		Student stu02 = new Student();
		stu02.subject = "计算机科学与技术系";

		Student.subject = "软件工程";	//建议使用类名直接调用

		System.out.println(stu01.subject);

		stu02.tellYouMySubject();

		Student.tellYouMySubject();	//建议这种方法(对静态方法建议直接使用类名调用)
	}
}

2.实例成员和类成员

static-静态的
2.1实例成员：实例变量和实例方法
2.2static关键字：类变量和类方法
类变量(静态变量)--被该类的所有实例对象所共享。

类方法(静态方法)--方法声明前加上static关键字。

class A{

	/*static*/ int count = 0;

	A(){
		count++;
		System.out.println("#" + count +"对象被创建");
	}
}

public class Demo3{
	public static void main(String[] args){
		A a01 = new A();
		A a02 = new A();
		A a03 = new A();
		A a04 = new A();
		A a05 = new A();
	}
}

2.3对类成员的调用
既可能通过实例对象来调用，也可能直接通过类名来调用。
在静态方法中，不能引用非静态成员。

2.4static和final关键字一起使用，也可以用来定义常量。常量的值不可修改。

class Circle{
	int r;
	static final double PI = 3.1415;	//static final定义常量

	public double getArea(){
		return PI * r * r;
	}

	public double getCircleLength(){
		return PI * r * 2;
	}
}

public class Demo4{
	public static void main(String[] args){
		Circle circle = new Circle();
		circle.r = 3;
		System.out.println("周长：" + circle.getArea());
		System.out.println("面积：" + circle.getCircleLength());
	}
}

3.初始化字段

3.1静态变量的初始化：

3.1.1使用静态代码块：在虚拟机的类加载器加载.class文件时，就执行。
3.1.2使用私有静态方法

3.2实例变量的初始化：

3.2.1构造器在new-创建实例对象的时候，才调用执行。

3.2.2初始化块：初始化块中的代码，实际上会被拷贝到每个构造器的开始。

3.2.3使用final实例方法进行初始化。

class Student{
	String name = initInstanceVar();
	static int count = 0;
	static int count2 = initStaticVar();
	int age = 0;
	
	//非静态代码块
	{
		System.out.println("这里是非静态初始化块，age:" + age);
		if(age<16)
			age = 16;
		System.out.println("非静态初始化结束，age:" + age);
	}

	protected final String initInstanceVar(){
		System.out.println("这里是final实例方法初始化");
		return "张三";
	}

	//静态代码块
	static{
		System.out.println("这里是静态代码块");
		count = 5;
	}

	private static int initStaticVar(){
		//执行一系列初始化的代码
		//...
		System.out.println("这里是私有静态方法进行静态变量初始化");
		return 8;
	}

	Student(){	//创建实例的时候才调用构造器
		name = "匿名";
		System.out.println("这里是构造器");
		
	}
}

public class Demo5{
	public static void main(String[] args){
		Student stu = new Student();
		System.out.println(stu.name);
	}
}

4. 嵌套类
   在一个类里面定义的类，称为“嵌套类”。嵌套类又分为两类：

   4.1 静态嵌套类：它等价于顶级类。
   4.2 非静态嵌套类：又叫“内部类”
   4.3 嵌套类的访问权限修饰符：private、包级私有、protected、public
   4.4 怎样使用嵌套类？

   还可以在一个方法内定义内部类：局部内部类和匿名内部类。
   匿名内部类是其中唯一需要关注的：在Swing的事件监听器中，会经常遇到这样的匿名内部类。在Android中，也会经常遇到匿名内部类。


5. Java的垃圾回收机制

   Java的程序是跑在JVM中的。不再需要的对象空间，就由JVM负责回收。
   垃圾回收线程，会自动查看没有引用的对象，并回收该对象的内存空间。
   好的做法是：当你能确定某个对象不再需要时，要主动地将其赋一个null值。