类的高级：访问修饰符、封装、静态类成员static、内部类；

访问修饰符：

公开访问（public）：对所有子类，非子类访问；

受保护的（protected）：只有同包子类、非子类、不同包子类可访问，不同包非子类不可访问；

私有的（private）：只有本类可访问，其子类不可访问；

默认（无修饰符）：只有同包子类、非子类访问，不同包子类、非子类不能访问；

访问修饰符的权限：

修饰符	本类	同包		不同包
		子类	非子类	子类	非子类
private	√	×	×	×	×
默认	√	√	√	×	×
protected	√	√	√	√	×
public	√	√	√	√	√

封装

封装：1：类的组装：一个类的组建（数据成员或方法）被声明为私有类型（private），则任何该类外部的方法都是无法访问该组件的。

　　　2：信息隐藏：1）：访问修饰符：访问修饰符的作用是限制属性和方法被使用和调用的范围。即指明了类的数据成员和方法的能够被访问的程度。

　　　　　　　　　  2）：方法：（1）：get/set方法的封装体现：（1：可以只提供get/set，把属性变为制度或只写；

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　    （2：get方法可以提供权限的验证，set方法可以提供数据有效性效验。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 （3：可以隐藏内部属性的存放；

　　　　　　　　　　　　　　　 （2）：功能的具体步骤：

封装好处：类成员变量可以称为制度或者只写的。

　　　　　类可以对存储在其成员变量中的内种有一个整体的控制。

　　　　　类的用户不需要知道类是如何存储数据的。

静态成员

　　static修饰的全局变量叫静态变量，也叫类变量，类变量的值为所有对象共享；

　　static修饰的方法叫静态方法，既类方法，类方法只能使用静态变量，而不能使用非静态的全局变量。

static属性：

1：当属性没有static修饰的时候：

（1：在语法上该属性必须用对象进行访问；”public String name“

（2：内存上该属性是放在每个对象上的（每个对象上有一个name属性）；

（3：语义上该属性是属于某个对象的；

（4：变量产生的时机，是在new对象的；

（5：根据语义分析，很少有变量属性是static的；

（6：普通属性，非静态属性；

2：当属性使用static修饰的时候：

（1：语法上虽然可以用对象进行访问，但更多的是用类名直接访问；

（2：在内存上，该属性是没有放在对象上的，而是存在数据段的静态区且全类共享一个；

（3：在语义上该属性是跟类相关而跟对象无关的；

（4：变量产生的时机，是在家在类的时候；

（5：常量通常都不变的，直接用设计static；

（6：静态属性，类属性；

static方法：

没有用static修饰的方法：

　　　　

public void study（）{

　　　　　　System.out.println("......");

　　　　}

　　

1：语法上必须使用对象进行调用；

2：非静态方法既可以操作静态属性也可以操作非静态属性，既可以调用其它的静态方法也可以调用其它的非静态方法；

3：家在上非static的方法被后加载；

4：语义上如果该方法与某个对象有关，就只能设计为非static的

5：设计上如果该方法的实现部分需要操作跟对象有关的属性或其它方法，那么该方法就应该设计为非static的；

使用static修饰的方法：

public static void study(){

　　System.out.println(".......");

}

　　

1：语法上虽然可以用对象进行调用，但更多的是用类名直接调用；

2：静态方法只能操作静态属性，调用其它静态方法，甚至不能写this/super；

3：在家在上static方法优先被加载；

4：语义上如果某个方法与某个对象吴福安，只与某个类有关，才设计为static的；

5：在设计上如果该类的工具类的工具方法，那么该方法应该设计为static的；

static共性：

1：凡是static的都是跟对象无关，都是类级别的；

2：凡是static的都是在加载期会有特殊处理；

static：1：可修饰符：含义（静态）——特点：（1：与对象有关，只与类有关；

　　　　　　　　　　　　　　　　　　　　　 （2：在加载期有特殊操作；

　　　  2：可修饰：（1：属性：1）：代表全类共享唯一值；2）：会在加载区产生在数据段静态区，不在对象上产生；3）：使用：常量属性，变量属性分析出全类共享；4）：语法：

　　　　　　　　　 （2：方法：代表类的方法；加载期工具方法；

　　　　　　　　　 （3：初始化快：

构造绝对不能用static： "public student （ ）{ "

　　访问修饰符:3个关键字，4种情况；

　　get/set的封装性：1）只读/只写；2）只对赋值机根据进行有效性限定；3）隐藏内部属性存放形式；

　　static 静态：

　　　　特点:1、与对象无关、该对象是指定义了static属性或方式的那个是伪对象

　　　　　　 2、加载期有特殊性；

　　　　可修饰性：1、属性：1）类属性、2）用法：可以用类或对象、3）效果：全类共享一个值、4）内存：为加载期产生在数据段的静态区；

　　　　　　　　　2、方法：1）类方法、2）用法：可以用类或对象、3）效果：不能操作到本类的非静态属性或非静态方法，也不能操作this或super对象、4）鸡汁：由于优先加载所以不能调用非静态的内容；

静态类初始化块：

　public class PersonBean {

	//实例初始化块

	//该代码块在new对象的构造的时候会被自动执行，new一次就执行一次

	//new对象构造方法要执行4步，该代码块在第3步之前执行，即在对属性进行初始化之前

	//因此先在初始化块中对属性进行赋值，会被第3步的赋值覆盖

	{

		System.out.println("Person的实例初始化块");

	}

	//静态初始化块

	//该代码块是在加载PersonBean的class的时候就被自动执行了

	//一个类只加载一次，所以静态初始化块也只执行一次

	//所以很多打开资源、开启链接的预加载动作可以写到静态初始化块中

	static{

		System.out.println("Person的静态初始化块");

	}

	//属性

	private String name;

	private int age = 20;

	private static int a;

	//构造

	public PersonBean(){

		System.out.println("PersonBean的构造");

	}

	public PersonBean(String name, int age){

		this.name = name;

		this.age = age;

	}

	//方法

	public String getName() {

		return name;

	}

	public void setName(String name) {

		this.name = name;

	}

	public int getAge() {

		return age;

	}

	public void setAge(int age) {

		this.age = age;

	}

}

　　

内部类：

　在java中，还可以在类的内部定义类。这种在类的内部定义的类，称为内部类。内部类所在的类称为外部类。

　　特点：独立的class文件；同样需要变异；同样可以产生对象；

　　使用内部类：是掌握java高级编程的一部分。

　　内部类可以分为4种：静态内部类，成员内部类，局部内部类，匿名内部类；

package com.lovo.innerclass;

//OutClass被称之为外部类

//所有的内部类都是一个独立的类，都拥有各自的属性、行为、构造等等
//每个内部类都会被编译成一篇独立的Class文件，文件名都带外部类类名$
public class OutClass {
	private int a;
	private static int b;
	//成员内部类
	//位置：直接写在外部类当中，位置和属性、构造、方法平行。
	//Class文件的名字：”外部类类名" + $ + "内部类类名”
	//可以有访问修饰符，代表是否可以在外部的类使用
	//不管带什么访问修饰符，本类（外部类）的所有方法都可以使用
	public class InnerClass1{
		public void innerMethod(){
			//内部类如果要调用外部类的属性，请书写下面格式：
			OutClass.this.a = 100;
		}
	}

	//静态内部类--成员内部类的特例
	//位置：直接写在外部类当中，位置和属性、构造、方法平行。
	//Class文件的名字：”外部类类名" + $ + "内部类类名”
	//可以有访问修饰符，代表是否可以在外部的类使用
	//不管带什么访问修饰符，本类（外部类）的所有方法都可以使用
	public static class InnerClass2{
		public void innerMethod(){
			//静态内部类只能使用外部类的静态属性或静态方法，请书写下面格式：
			OutClass.b = 100;
		}
	}

	public void test1(final int e){
		this.a = e;
		final int A = 1200;
		//局部内部类
		//位置：直接写在外部类的方法当中，其位置和局部变量平行。
		//Class文件的名字：”外部类类名" + $ + "序号" + "内部类类名”
		//没有访问修饰符，只能在所定义的外部类方法中使用
		class InnerClass3{
			public void innerMethod(){
				//局部内部类不能操作它所在方法的局部变量（非常特殊）
				System.out.println(OutClass.this.a);
				System.out.println(e);
			}
		}

		//直接产生内部类对象
		InnerClass3 in = new InnerClass3();
		in.innerMethod();
	}

	public void test2(){
		//匿名内部类--是局部内部类的特例
		//位置：直接写在外部类的方法当中，其位置和局部变量平行。
		//Class文件的名字：”外部类类名" + $ + "序号"
		//在产生对象的同时去定义这个类，只能用这一次
		new Object(){
			public void introduce(){
				//匿名内部类不能操作它所在方法的局部变量（非常特殊）
				System.out.println("我可不是Object哦~~~");
			}
		}.introduce();
	}
}

　　所有的内部类都是一个独立的类，都拥有各自的属性、行为、构造等；每个内部类都会被编译程一篇独立的class文件，文件名都带外部类类

　　位置：直接写在外部类当中，位置和属性，构造，方法平行；

　　　　   class文件名字是“外部类类名” + $ + “内部类类名”；

　　　　　可以有访问修饰符，代表是否可以在外不使用；

　　　　　不管带什么访问修饰符，本类（外部类）的所有方法都可以使用；

　　在外部使用成员内部类——首先产生外部类对象，然后使用特殊语法外部类对象；new产生内部类对象，然后在调用内部类对象的属性或方法（受访问修饰符限制）；

　　

public class TestInnerClass {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//在外部使用成员内部类--首先产生外部类对象、然后使用特殊语法外部类对象.new
		//产生内部类对象，然后再调用内部类对象的属性或方法（受访问修饰符限制）
		OutClass out = new OutClass();
		OutClass.InnerClass1 oi = out.new InnerClass1();
		oi.innerMethod();

		//在外部类使用静态内部类---可以用外部类类名直接访问操作，无需产生外部类对象
		OutClass.InnerClass2 oi2 = new OutClass.InnerClass2();
	}

}

　　

小结：

　　访问修饰符：公有的（public）、受保护的（protected)、私有的（private)、默认的（无访问修饰符）；

　　通过private访问修饰符隐藏类中的成员变量，称为封装；

　　静态成员变量或静态方法并不与类的每个实例关联。静态成员变量或静态方法只有单个实例，他们对类的所有实例以及程序中的其它类是共享的；

　　静态初始化块在类装载时执行。实例初始化块在类被实例化时执行，在构造器中调用之间调用。

　　内部类是在类的内部定义的类。内部类四中形式：静态内部类、成员内部类、局部内部类、匿名内部类；

类：属性、构造、方法、初始化块、内部类、