1. 先创建一个接口

2. 在类的后面加 implements 接口

3. 添加接口方法 

@Override

public void playGame() {

// TODO 自动生成的方法存根

System.out.println("具有了玩游戏的功能");

}

    4.调用

       接口 接口名 = new 接口();

        接口名.目标类下的方法(); //实现调用

    5.如果有多个接口，则新建接口2，implements IPlayGame就可以

使用匿名内部类的方式实现接口：

第一种：

接口 接口名 = new 接口() 

{

    @Override

    public void playGame() {

    // TODO 自动生成的方法存根

    System.out.println("使用匿名内部类的方式实现接口");

    }

}; //注意这里要加分号

接口名.目标类的方法();

第二种： (接口名 不用出现)

new 接口（）

{

    @Override

    public void playGame() {

    // TODO 自动生成的方法存根

    System.out.println("使用匿名内部类的方式实现接口2");

    }

}.目标类的方法();

1、当一个类型变大，或者说向上类型转换，就可以直接像“赋值”一样等号过去。

如果当一个类型要变小，或者说向下类型转换，

（要转换的类型） 对象名

2、instanceof 

用法：

animal instanceof cat  

返回 布尔型

正确则可以强制类型，

不正确则不可以强制类型。

equals()方法

调用的方法，原先的对象.equals(输入的对象)

1. 先判断这这两个对象的地址码是不是相同，相同则正确（输入和原来的对象地址是空，且相等，也算他们是一样的）

2. 判断输入的对象的地址是不是空，是空则返回错误。

3. getClass() 和 obj.getClass() 获得对象包含的种类（类对象）是不是一样，不一样就返回错误。一样不操作。

4. 把输入的对象强制转化为原对象的格式，然后在比较它们共有的对象的属性，如果值不相同，则返回错误；值相同，则返回正确。
   

super的应用

Object类

1. Object类是所有类的父类

2. toString

   1. 在Initail.java里面

                Dog dog = new Dog();

                System.out.println(dog); //打印类的对象 会输出 对象的地址

            2. 在Dog.java类下，source里面的toString就可以自动生成打印出对象和对象属性的功能。

继承初始化顺序

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

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

3、 创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名= new 内部类();

                                    Java中的方法重写

        1.什么是方法的重写：

          如果子类对继承父类的方法不满意，是可以重写父类继承的方法     的， 当调用方法时会优先调用子类的方法。

         2.语法规则：

          a.返回值类型

          b.方法名

          c.参数类型及个数

           都要与父类继承的方法相同，才叫方法的重写。

                                      Java中的继承

         1.继承的概念：

           继承是类与类的一种关系，是一种“is a”的关系

                    注：java中的继承是单继承

          2.继承的好处:

            子类拥有父类的所有属性和方法

              实现代码复用

                          private修饰的无效

          3.语法规则：

                  class 子类 extends 父类

                   例：class Dog extends Animal{

}

package com.imooc;
public class Person{
public void say(){
System.out.println("人具有说话的能力");}}
public class Chinese extends Person{
public void say(){
System.out.println("中国人说中国话");}}
public class American extends Person{
public void say(){
System.out.println("美国热说英语");}}
public class Test{
public static void main(String[]args){
Chinese p=new Chinese();
American p2=new American();
p.say();
p2.say();}}
public abstract class APerson{
public abstract void say();
}

方法内部类就是内部类定义在外部类的方法中，方法内部类只在该方法的内部可见，即只在该方法内可以使用

一定要注意哦：由于方法内部类不能在外部类的方法以外的地方使用，因此方法内部类不能使用访问控制符和 static 修饰符。

super

super就好像可以替代父类名一样。

super.age 

super.eat()

在子类的构造方法中没有显示调用父类的构造方法super()，系统就会默认调用父类的无参构造方法。

如果父类的构造方法中有带参数的，又没有定义无参的构造方法，在子类的构造方法中又没有显式调用父类的构造方法，编译就会报错。

静态内部类是 static 修饰的内部类，这种内部类的特点是：

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

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

3、 创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名= new 内部类();

成员内部类  普通内部类

1. 和上一节的内容相似。

    编译之后产生两个 .class 文件

    第一个是内部类的 .class

    第二个是内部类的,  外部类名$内部类名.class 

                        l例如        Outer$Inner.class

    2.如果外部类和内部类是普通的类（没有用static修饰），

    如果外部类和内部类的成员变量或者方法相同，可以利用this来区分。（0static静态类不用this）

public void outer{

int b = 1;

    public void Inner{

    int b =2;

    public void test(){

        System.out.println("Outer:" + Outer.this.b);  //这里打印出1    用this的话，则指外部类

        System.out.println("Inner:" + b);         //这里打印出2    如果不指定，默认是内部类

            }

    }

}

    3.当要内部类去创建一个对象的时候，

            内部类名 对象名 = 外部类名.new 内部类名();

 如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的成员变量，可以使用 this 关键字。如

final关键字

final 类，则这个类 不可以继承

final 方法，则这个方法 无法被覆盖（重写）

final 属性    类的初始化必须有值

                  在构造法中赋值

final 变量  只能在定义的时候赋值，即常数。