目录
1：封装的概念
面向对象程序的三大特性：封装，继承，多态。
封装：对类内部的实现细节进行封装，对外只提供一些公开的接口。
| NO | 范围 | private | default | protected | public |
| 1 | 同一包的同一类 | Y | Y | Y | Y |
| 2 | 同一包中不同类 | N | Y | Y | Y |
| 3 | 不同包中子类 | N | N | Y | Y |
| 4 | 不同包中的非子类 | N | N | N | Y
|
Y:可以 N：不可以
说明：访问限定符只是对权限的限定。这些限定符都可以修饰类名，修饰方法，修饰成员变量。
default：默认值，对包内进行访问。
private: 私有制的，只能在类的内部进行访问。
2.包的概念
1.使用import语句导入包
例如：import .java.util.Arrays,这是导入一个具体的包。
import .java.util*,你将用到谁，就会导入具体的包。
2.import static 导入包中静态的方法和字段。
注意：
import 语句可以导入具体的类，不可以导入具体的包。
3.static成员
3.1：static修饰成员变量
static 修饰的成员变量，称为静态成员变量。
静态成员变量最大的特性：不属于莫个具体的对象，是所有对象的共享。
public class Main {
static boolean Paddy;
public static void main(String args[]){
System.out.println(Paddy);
}
}猜一下，这道题输出是多少，
是false------静态成员未没有初始化，会有默认值，但局部变量没有初始化，会报错。
3.2：static 修饰成员方法
注意：
static 修饰类的变量和类的方法。
不赋值，默认是NULL，不依赖于对象。
public class Main {
public static void main(String[] args) {
Test test=null;
test.hello();
}
class Test {
public static void hello() {
System.out.println("hello");
}
}
｝看看这道题，猜这道题会输出啥？
输出的是hello-------static修饰成员方法，不依赖于对象，可以用类名+点+成员方法。
public class HasStatic {// 1 private static int x = 100;// 2 public static void main(String args[]) {// 3 HasStatic hsl = new HasStatic();// 4 hsl.x++;// 5 HasStatic hs2 = new HasStatic();// 6 hs2.x++;// 7 hsl = new HasStatic();// 8 hsl.x++;// 9 HasStatic.x--;// 10 System.out.println(" x=" + x);// 11 } }
从这道题可以知道，静态成员变量在方法区。
静态方法的特征
1，不属于莫个具体的对象，是类方法。
2，可以通过对象调用，可以通过类名，静态方法名的方式调用。
3， 不可以在静态方法中访问任何非静态成员变量。
4.代码块
4.1：代码块的分类
1.实例代码块---代码块
2,静态块----static修饰,一般初始化静态变量。
4.2：静态代码块
ublic class HasStatic {// 1
static int cnt = 6;//静态变量
static{//静态代码块(第一个静态代码块）
cnt += 9;
}
public static void main(String[] args){
//{} 这是普通代码块
System.out.println("cnt = " + cnt);
}
static{//第二个静态代码块
cnt /=3;
};
}这个输出的是5。
是因为：先运行静态代码块（在类创建时就是运行），之后是实例代码块，最后是构造方法。
注意事项：
1.静态代码块不管生成多少个对象，只会执行一次。
2.如果一个类中包含多个静态代码块，编译器按照定义的先后次序依次执行。
3.实例代码块只有在创建对象时才会执行。
5.内部类
5.1：内部类的分类
1.实例内部类-----未被static修饰。
2.静态内部类-----被static修饰。
3.局部内部类
5.2：实例内部类
public class OutClass { private int a = 10;//原地复制 static int b = 20; int c = 30; public void method() { System.out.println("OutClass::method"); } class IntClass {//实例内部类 int d = 40; int c;//这里和外部类的成员变量同名。 public void method2() { a = 100; b = 200; System.out.println(a+" "+b+" "+OutClass.this.c+" "+d); //OutClass.this.c：这里是调用外部类的c method();//调用外部类的方法 } } public static void main(String[] args) { OutClass c1=new OutClass();//闯将外部类对象c1; System.out.println(c1.a); System.out.println(c1.b); System.out.println(c1.c);//调用外部类的成员变量 OutClass.IntClass c2=c1.new IntClass();//这里是先创建了外部类对象 //这里是创建实例内部类对象c2; //如果木有先创建外部类对象，创建实例内部类对象c3; //OutClass.IntClass c3=new OutClass().new IntClass(); c2.method2();//调用内部类的方法 } }
注意：
1.实例内部类不能有静态成员变量。非要定义，只能用 static final 修饰
2.如果实例内部类访问外部类相同名的成员变量，外部类的类名.this.成员变量.
3.外部类中的任何成员都可以直接在实例内部类方法中直接访问。
4.实例内部类对象必须在先有外部类对象前提下才能创建。
5.外部类，不能直接访问内部类的成员，如果访问，必须创建内部类对象
5.3：静态内部类
public class OutClass1 {
private int a = 10;
static int c;
public void method() {
System.out.println(a+" "+c);
}
static class IntClass {//静态内部类
static int d = 100;
public void method1() {
//a = 100;//这里报错了，因为a不是静态变量。
c = 200;
// method();//这里报错，因为这个不是静态内部类的成员方法。
System.out.println(c+" ");
}
}
注意事项：
1.在静态内部类中只能访问外部类中的静态成员。
2.创建静态内部类对象时，不需要先创建外部类的对象。
5.4：局部内部类
注意事项：
1.局部内部类只能在定义的方法体内部使用
2.不能被public static 修饰。