1、 静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问 

使用对象：

1、创建对象

        类名 对象名 = new 类名();

        Telphone phone = new Telphone();

2、使用对象

        引用对象的属性：对象名.属性

        phone.screen = 5；//给screen属性赋值5

        引用对象的方法：对象名.方法名()

        phone.sendMessage();//调用sendMessage()方法

怎么去定义一个类？

1. 定义类名

2. 编写类的属性（即成员变量）

3. 编写类的方法

public class 类名{

//定义属性部分（成员变量）

属性1的类型  属性1;

......

属性n的类型  属性n;

//定义方法部分

方法1;

.....

方法n;

}

内部类也是一个类

类：确定对象将会拥有的特征（属性）和行为（方法）

类是对象的类型

具有相同属性和方法的一组对象的集合

属性：是对象具有的各种特征（注：每个对象的每个属性都拥有特定值）[即有什么]

方法：是对象执行的操作【即可以做什么】

有参的构造方法可以与无参的构造方法并存

这是重点图片

静态类：
1.使用static修饰的内部类

2.静态类不能访问外部类的非静态成员，但可以通过new 外部类().成员  的方式访问；

3.如果外部静态成员和内部类的成员名称相同，可通过 类名.静态成员 访问外部类的静态成员；如果外部静态成员与内部类的成员名称不同，则可能过 成员名 直接调用外部类的静态成员；

4.创建静态内部类的对象时，不需要外部类的对象，可直接创建： 内部类 对象名=new 内部类()；

方法内部类：

1. 方法内部类是定义在外部类的方法中，只在该方法的内部可见，即只在该方法内部可用；

2. 方法内部类不能使用 访问控制符和static修饰符
   

一般静态变量都是公用的、全局的，程序一启动就会在内存开辟一块空间，存放它们。静态的不必实例化就能直接使用，是说在没有生成任何对象时就能运用该方法，所以静态方法里不能对非静态的成员变量做操作。一般静态方法操作静态成员变量或全局变量。

要搞清楚这个问题，我们需要清楚他们之间有什么区别，有什么优势和劣势。

首先看看静态与非静态方法的区别：

静态方法　　　　　　　　　　　　　　　　　 　 |  实例方法

1、静态方法可以通过“类.方法()”调用 　 　　　　 | 要在对象实例化后使用对象调用

2、只能使用静态变量和局部变量　　　　　　　　| 所有变量都可以使用

3、静态方法不能被子类重写　　　　　　　　　　| 实例方法可以

4、接口不能定义静态方法　　　　　　　　　　   | 实例方法可以

从上面区别来看，静态方法只有一个优势，就是调用的时候不用实例化，其他情况下跟实例方法相比都是处于劣势。那么我们在什么情况下会使用到静态方法？相信大家第一时间会想到一样的东西，工具类Util。工具类给我们开发带来了大大的方便，归根到底是“不用实例化就能用”的功劳。这是静态方法的一个优势。

而静态方法的劣势也很明显，局限性很大，不能重写，不能引用普通变量，接口不能定义等等。。。可能还有很多我没列举出来。

那究竟什么时候该用静态方法？我们就要最大化利用其优势而避其缺点：

1、一个方法完成一个独立的功能，而且不会干扰到其他方法或变量，则即使删掉这个方法，对其他东西都没有任何影响。

2、不依赖构造方法，不依赖接口，不依赖继承。（这也是为什么越学面向对象，越会纠结这个问题）

举个例子：String类即使删掉 static valueOf(Object obj)方法，也不会影响实例方法chatAt(int index)的使用。当然它可能会影响其他重载的valueOf方法。

至于现在网上很多资料都有一个误区，就是说静态方法一开始加载，会占用内存，而实例方法不会。这个说话其实是错误的，它们都是一样一开始就会加载，而且只会占用一份内存。因为方法不是变量，它只需要有一份内存就够了。而变量则不一样

-----------------------------------------------------------------------------------------------------------------------------------------------------------

下面来看看静态变量与非静态变量

静态变量　　　　　　　　　　　　　　　　　 　 |  非静态变量

1、可以通过“类.变量”来引用。　　　　　　　　  | 只能通过实例对象来引用。

2、程序运行时分配内存　　　　　　　　　　　　|  类实例化时分配内存。

3、只有一份内存被分配　　　　　　　　　　　　|  有多少个类被实例化，就有多少个该类的变量那么多份内存被分配。

4、静态变量定义后必须声明初始化　　　　　　   | 非静态变量可以延迟初始化。

其他.....

很明显，静态变量拥有的优势不少，第一点不用说。第2、3点可以利用它来做一个整个程序的全局变量，因为任何修改都只会指向同一份内存。

而第3点优势恰好就是我们的“饿汉式单例模式”的一个最简单的实现。

成员内部类（普通内部类）
1.Inner 类定义在Outer类内部，相当于一个成员变量的位置 ，Inner类可以使用任意访问控制符，如public、protected、private等；

2.成员内部类中定义的方法可以直接访问外部类的数据，面不受控制符的影响，如直接访问外部类中的私有属性；

3. 定义了成员内部类后，外部类不能直接使用内部类的成员和方法。必须使用外部类对象来创建内部类对象，而不能直接new一个内部对象，即:
   内部类 对象名=外部类对象.new 内部类（）

然后通过内部类的对象来访问其成员变量和方法。

4.编译后，产生了两个.class文件，外部类的.class文件（外部类名.class）,内部类的.class文件（外部类名$内部类名.class）

5.如果外部类和内部类有相同的成员变量或方法时，内部类默认访问自己的成员变量或方法，如果要访问外部类的成员变量，可以使用this关键字（外部类名称.this.成员变量）

程序运行时静态初始化块最先被执行，然后执行普通初始化块，最后才执行构造方法。

1、 静态方法中可以直接调用同类中的静态成员，但不能直接调用非静态成员。

如果希望在静态方法中调用非静态变量，可以通过创建类的对象，然后通过对象来访问非静态变量。

2、 在普通成员方法中，则可以直接访问同类的非静态变量和静态变量，

3、 静态方法中不能直接调用非静态方法，需要通过对象来访问非静态方法。

接口就是用来被继承，被实现的，修饰符一般建议用public

注：不能使用private和peotected修饰接口

接口是可以多继承的，类只能单继承