在一个类1里面又定义了一个类2，那么类1称为外部类，类2就是内部类。

同一个包中的其他类，是不允许再访问内部类（类2的）。

内部类方法可以直接访问外部类的所有数据，包括私有数据（private）。

外部类也可以访问内部类的属性、方法，需要通过创建内部类的实例对象来访问。

内部类的private类型的方法或属性，外部类也可以访问。

抽象类：abstract:约束子类有什么方法，并不关注怎么去实现

1. 使用规则：包含抽象方法的类是抽象类，但抽象类也可以没有抽象方法

                    abstract只有声明，不需要实现

2. 在选择class的时候会，记得选择abstract

   父类中的写法：

   public absstrat message();

   子类中则正常定义则可 public void message(){}

3. 另一个类要选择继承抽象类(父类)

4. 创建了子类后，自动出现抽象模块

5. 最后调用：：父类类名   对象名=new  子类类名，对象名.方法（）；
   

this就代表着当前对象；

this.属性：代表调用当前对象的属性；

this.方法：代表调用当前对象的方法；

一般可以通过使用this的形式，防止搞混相同名字的对象的属性和参数，一般在get、set方法中可以常常看到。

例：

前面的this.screen的‘screen’，是对象的screen属性，等号后面的‘screen’，是传过来的screen参数，是用来赋值的，所以可以区分。

同理，可以this.方法(),来调用本对象的方法，防止和其他方法搞混。

修饰符的使用范围：

应用类型转换

1. 向上类型转换：小-》大（自动类型转换）

   ps: Dog dog =new Dog();

        Animal animal=dag;

         可以这么写//自动类型提升  向上类型转换
   

        但是不能Dog dog2=animal//虽然此时animal就是dog类，但是编译器自动认为有问题

   解决办发； Dog dog2=(Dog)animal;//向下类型转换

   但此时不能写 Cat cat1=(Cat)animal;//因为animal是dog类型

2. 向下类型转换：大-》小（强制类型转换）

3. instanceof运算符解决应用对象的类型

   
   

         用intanceof 判断animal中是否有cat的元素，没有就不允许转换

封装步骤：

1、设置属性的可见性为 private ---->2、创建getter、setter方法，用于属性的读、写操作 --->/3、在getter、setter方法中加入属性的控制语句，可以对属性值的合法性增加判断。

第3步可以有可以没有

所谓封装，就是把类的属性、方法什么的设置为private，这样就把这些特性都封装在类内部了，外部程序不能直接访问了。

如果外部程序想访问，一般可以通过get、set方法来访问（也有其他的方法，但是get、set比较常用）

设置private属性

创建getter、setter方法

调用get、set方法

面向对象三大特性：封装、继承、多态

对象具有多种形态

1. 引用多态：父类的引用可以指向本类的对象：Animal是父类，dog是子类

                        Animal obj1=new Animal

                  /父类的引用可以指向子类的对象

                        Animal obj2=new Dog();
   

2. 方法多态

                 创建本类对象时，调用的方法是本类方法

                  创建子类对象时，调用的方法是子类重写的方法或者继承 的方法，但是不能调用子类独有的方法

2.equals()方法：比较的是对象的引用是否指向同一块内存地址

例如：两个对象是否指的一个手机，但一般情况是比较值是否一样，所以我们进行重写就好了

怎么比较？

1.  if(dog1.equals(dog2))

只要是创建了两个对象，就开辟了两个空间，结果都是false

如果改为if(dog1==dog2),也是比较内存地址是否相同

2.比较属性是否相同（同一类型）

  不用自己写，在source中有一个生成equals方法：（重写）

   Generate hashCode() and equals  (hashcode:唯一标识一个对象的  )

  ps:getClass:类对象，不是类的对象

2.equals()方法：比较的是对象的引用是否指向同一块内存地址

例如：两个对象是否指的一个手机，但一般情况是比较值是否一样，所以我们进行重写就好了

怎么比较？

1.  if(dog1.equals(dog2))

只要是创建了两个对象，就开辟了两个空间，结果都是false

如果改为if(dog1==dog2),也是比较内存地址是否相同

2.比较属性是否相同（同一类型）

  不用自己写，在source中有一个生成equals方法：（重写）

   Generate hashCode() and equals  (hashcode:唯一标识一个对象的  )

  ps:getClass:类对象，不是类的对象

类对象更关注代码，类的对象更关注属性的值

 在重写equals后，又调用它，就能得到正确 的答案。

类对象更关注代码，类的对象更关注属性的值

 在重写equals后，又调用它，就能得到正确 的答案。

final修饰的类不允许继承，final修饰的方法不允许被覆盖或重写

final修饰的变量只能赋值一次，不允许再次赋值

final修饰的变量必须自己初始化，若没有，则必须在构造函数进行初始化

变量的初始化顺序：父类的属性初始化>父类的构造方法初始化>子类的属性初始化>子类的构造方法初始化

abstract class Person {

    public abstract void eat();

}

class Child extends Person {

    public void eat() {

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

    }

}

在main方法中调用时

Person p = new Child();     

p.eat();

以上可以写成

 Person p = new Person() {

            public void eat() {

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

            }

        };

        p.eat();

    }

注意点：1、匿名类必须且只能实现一个抽象类或继承一个接口

              2、匿名类不能构造函数

              3、匿名类不能有静态方法和静态变量

              4、形参若要被内部类使用，必须final修饰

              5、匿名内部类最后以分号结束

1、方法内部类是定义在方法内的类，不是外部类的一部分，不属于外部类，因此不能有访问修饰符和static，且只能在方法内实例化

2、不能在静态方法内创建内部类，因为外部类加载时，内部类尚不存在，静态方法无法创建内部类

3、内部类调用外部类成员的方法与成员内部类相同，但是只能调用final修饰的成员

4、外部类调用内部类直接用外部类的对象来引用方法

1、成员内部类隐含地保存了一个引用，指向创建它的外围类对象，而静态内部类则没有

2、由于类加载时，外部类的实例变量尚未开辟空间，而静态内部类已经开辟空间，因此静态内部类只能访问外部类的静态成员

3、由于类加载时，静态内部类已经开辟空间，因此外部类调用静态内部类时，实例化内部类即可

4、由此可看出，静态内部类时独立于外部类，不需要外部类对象