接口是一个类的规范，都是抽象方法。也用abstract关键字修饰，系统会默认给添加上

当两个对象是不同类，但是又可以用共同的方法，比如iPhone和PSP都可以玩游戏，但是iPhone是手机，PSP不是，此时可以新建一个IPlayGame的接口，用于存储不同类的共同方法以便调用。接口类命名时开头加上“I”以便于和其他类区分开

类用class表示，接口用interface表示

类只能继承一个父类，接口可以继承多个父类

接口中定义的属性值都是常量，即用public static final来修饰，系统会默认给添加上

接口一般是用于被其他类继承和实现的，所以接口中定义的方法都是public修饰的

使用接口，用implements关键字

public class 类名 extends 父类 implements 接口1,接口2,..{

}

android的高级框架中，经常会通过匿名内部类的方式实现接口，两种形式：

package trafficTools;

public class Transportation {
    public static void main(String[] args) {
        //接口与匿名内部类一起用,new一个接口，直接在接口中实现要用的方法，接口最后以;结尾，实现了后就可以调用我们的接口
        IPlayGame iPlayGame3 = new IPlayGame() {
            @Override
            public void playGame() {
                System.out.println("使用匿名内部类的方式实现接口");
            }
        };
        //调用实现的接口
        iPlayGame3.playGame();
        
        //或者是直接new一个接口的方式实现接口，然后接口.方法直接调用接口中实现的方法
        new IPlayGame() {
            @Override
            public void playGame() {
                System.out.println("使用直接new一个接口的方式，通过匿名内部类实现接口");
            }
        }.playGame();
    }
}

成员变量和局部变量

演示示例：

成员变量和局部变量

修改 private  

创建 get、set

静态初始化块优先执行

内部类需要通过外部对象才能调用

Inner i = hello.new Inner();

记得 void 可以无返回值   其他类型需要有返回值

静态变量用  static    

抽象类。

abstract关键字来修饰，是定义规范，用来约束子类必须有哪些方法，但是具体怎样用这些方法，就是子类的事了。

abstract可以修饰类和方法，修饰的方法是没有方法体的，也就是不需要{}

抽象类中可以存在普通方法

抽象类不能直接创建，通常是定义引用变量，指向子类对象

子类继承父类后，重写父类的抽象方法为自己所用

其他类就可以在调用子类的时候，用子类重写的方法了

package shape;
//定义一个抽象类，在class前用abstract修饰
public abstract class Shape {
    //定义抽象方法，周长和面积，抽象方法是不能有方法体的
    public abstract void circumference();
    public abstract void square();
}

package shape;

public class Circle extends Shape {

    @Override
    public void circumference() {
        System.out.println("圆的周长是C=2πr");
    }

    @Override
    public void square() {
        System.out.println("圆的面积是S=πr²");
    }
}

package shape;

public  class Rectangle extends Shape {

        @Override
        public void circumference() {
            System.out.println("矩形的周长是C=4l");
        }

        @Override
        public void square() {
            System.out.println("矩形的面积是S=ld");
        }
}

package shape;
//写一个计算类，然后引用矩形和圆中的方法
public class Calculate {
    public static void main (String[] args){
        Shape shape1 = new Circle();
        Shape shape2 = new Rectangle();
        shape1.circumference();
        shape1.square();
        shape2.circumference();
        shape2.square();
    }
}

引用类型转换。

向上：狗是动物  猫是动物

向下：动物是狗的一种

向下：猫是动物的一种

package animals;

public class NaturalHunter {
    public static void main(String[] args) {
        //初始化?这个对象
        Dog dog1 = new Dog();
        //向上类型转换，?是动物
        Animals animals = dog1;
        //向下类型转换，把动物指定成?,在animals前面加上要强转的类型
        Dog dog2 = (Dog) animals;
        //向下类型转换，把动物指定成?,在animals前面加上要强转的类型,虽然没有报错，但是运行时会有问题的。
        //因为初始化的类型是?，是没有办法让?指定成?的，此时用到了instanceof,避免不能转化时报错。
        // 搭配if使用，如果动物能转换成?，就转换；如果动物不能转换成?，输出提示
        //Cat cat = (Cat) animals;//编译是是Cat，运行时是Dog
        if (animals instanceof Cat) {
            System.out.println("可以将类型转换为?");
            Cat cat = (Cat) animals;
        } else {
            System.out.println("无法将类型转换为?");
        }
    }
}

成员变量有初始值，局部变量无初始值

变量同名，局部变量比成员变量优先级更高

Object类是所有类的父亲，

如果一个类没有使用extends关键字明确标识继承另外一个类，那么这个类默认继承Object类。

1、toString（）方法 

Object类中定义toString方法的时候返回的对象的哈希code码（对象地址字符串 ）

可以重写toString方法表示出对象的属性 

用Source选项中的功能可以快速生成toString方法

interface:

Java中的方法内部类

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

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

JAVA中的静态内部类

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

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

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

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