接口（interface）

接口不是类

接口中都是静态常量，没有成员变量，接口的属性实际上被public static final 修饰，因为有static修饰所以可以用接口名直接调用

package cn.tedu.Inter2;
//本类用于进一步测试接口的使用
public class TestUserInter {
    public static void main(String[] args) {
        System.out.println(UserInter.age);
    }
}
interface UserInter{
    int age=10;
}
运行结果：
10

接口中的方法都是抽象方法，没有普通方法，也没有构造方法；且接口中的方法可以省略public abstract

public abstract void eat();
void eat();

接口可以用多态的方法生成对象

package cn.tedu.inter;
//本类用于接口测试
public interface Inter {
    public abstract void eat();
    public abstract void play();
}

package cn.tedu.inter;
//本类是inter接口的实现类
public class InterImpl implements Inter{
    @Override
    public void eat() {
        System.out.println("吃火锅");
    }

    @Override
    public void play() {
        System.out.println("打代码");
    }
}

public class InterTest {
    public static void main(String[] args) {
        Inter i=new InterImpl();
        i.eat();
        i.play();

    }
}
运行结果：
吃火锅
打代码

接口可以用接口实现类生成对象

package cn.tedu.inter;
//本类用于接口测试
public interface Inter {
    public abstract void eat();
    public abstract void play();
}

package cn.tedu.inter;
//本类是inter接口的实现类
public class InterImpl implements Inter{
    @Override
    public void eat() {
        System.out.println("吃火锅");
    }

    @Override
    public void play() {
        System.out.println("打代码");
    }
}

public class InterTest {
    public static void main(String[] args) {
        InterImpl i1=new InterImpl();
        i1.eat();
        i1.play();
    }
}
运行结果：
吃火锅
打代码

接口实现类（implements）

接口实现类中有构造方法，父类为*父类object

接口和实现类建立关系后，有两种方案：

1.不实现接口中的抽象方法，将自己变成抽象类

abstract public class InterImpl implements Inter{}

2.实现接口中的所有抽象方法，将自己变成普通子类

public class InterImpl implements Inter{
    @Override
    public void eat() {  
    }
    @Override
    public void play() {
    }
}

类与接口

针对Java的类，一个类只能有一个父类，及单继承；但是一个类可以实现多个接口，及多实现\

接口和抽象类的比较：

接口是先天设计的结果，抽象是后天重构的结果

抽象类有构造方法，接口都没有构造方法，都不可以实例化

内部类

内部类对象的创建

package cn.tedu.innerclass;

import cn.tedu.inter.Inter;

//测试内部类的入门案例
public class TestInner1 {
    public static void main(String[] args) {
        //成员内部类对象的创建
        Outer.Inner oi = new Outer().new Inner();
        System.out.println(oi.sum);
        oi.delete();
    }
}
class Outer{
    String name;
    private int age;
    public void find(){
        System.out.println("外部类...find()方法");
        
    }
    //成员内部类......
    class Inner{
        int sum=10;
        public void delete(){
            System.out.println("内部类的delete()方法");
            
        }
    }
}
运行结果：
10
内部类的delete()方法

内部类可以直接使用外部类的资源，包括私有资源

package cn.tedu.innerclass;

import cn.tedu.inter.Inter;

//测试内部类的入门案例
public class TestInner1 {
    public static void main(String[] args) {
        //成员内部类对象的创建
        Outer.Inner oi = new Outer().new Inner();
        System.out.println(oi.sum);
        oi.delete();
    }
}
class Outer{
    String name;
    private int age;
    public void find(){
        System.out.println("外部类...find()方法");
        
    }
    //成员内部类......
    class Inner{
        int sum=10;
        public void delete(){
            System.out.println("内部类的delete()方法");
            System.out.println(name);
            System.out.println(age);
            find();
        }
    }
}
运行结果：
10
内部类的delete()方法
null
0
外部类...find()方法

外部类可以通过创建对象调用内部资源

package cn.tedu.innerclass;

import cn.tedu.inter.Inter;

//测试内部类的入门案例
public class TestInner1 {
    public static void main(String[] args) {
        //成员内部类对象的创建
        Outer.Inner oi = new Outer().new Inner();
        System.out.println(oi.sum);
        oi.delete();
    }
}
class Outer{
    String name;
    private int age;
    public void find(){
        System.out.println("外部类...find()方法");
        //通过对象调用内部资源
        Inner in=new Inner();
        System.out.println(in.sum);
        in.delete();
    }
    //成员内部类......
    class Inner{
        int sum=10;
        public void delete(){
            System.out.println("内部类的delete()方法");
        }
    }
}
运行结果：
10
内部类的delete()方法

成员内部类被private修饰，可以创建外部类的对象，间接访问内部类的资源

package cn.tedu.innerclass;
//本类测试成员内部类被private修饰
public class TestInner2 {
    public static void main(String[] args) {
        new Outer2().getInner2Eat();
    }
}
class Outer2{
    public void getInner2Eat(){
        Inner2 in=new Inner2();
        in.eat();
    }
    private class Inner2{
        public void eat(){
            System.out.println("内部类的eat()方法");
        }
    }
}
运行结果：
内部类的eat()方法

成员内部类被static修饰时的调用

package cn.tedu.innerclass;
//测试内部类被static修饰
public class TestInner3 {
    public static void main(String[] args) {
        Outer3.Inner3 oi = new Outer3.Inner3();
        oi.show();
    }
}
class Outer3{
    static class Inner3{
        public void show(){
            System.out.println("内部类的show()方法");
        }
    }
}
运行结果：
内部类的show()方法

成员内部类和内部类中的方法被static修饰

package cn.tedu.innerclass;
//测试内部类被static修饰
public class TestInner3 {
    public static void main(String[] args) {
      
        Outer3.Inner3.show2();
    }
}  
class Outer3{
    static class Inner3{
        public void show(){
            System.out.println("内部类的show()方法");
        }
        public static void show2(){
            System.out.println("我是静态内部类的静态方法");
        }

    }
}

局部内部类的调用需要在局部内部类的下面

package cn.tedu.innerclass;

import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;

//用来测试局部内部类
public class TestInner4 {
    public static void main(String[] args) {
        new Outer4().show();
    }
}
class Outer4{
    public void show(){
        System.out.println("我是外部类的show()方法");
        class inner4{
            String name;
            int age;
            public void eat(){
                System.out.println("我是局部内部类的eat()");
            }
        }
        inner4 in = new inner4();
        System.out.println(in.age);
        System.out.println(in.name);
        in.eat();
    }
}
运行结果：
我是外部类的show()方法
0
null
我是局部内部类的eat()

匿名内部类没有名字，通常与匿名对象结合在一起使用。匿名对象只能使用一次，一次只能调用一个功能

package cn.tedu.innerclass;
//用于测试匿名内部类
public class TestInner5 {
    public static void main(String[] args) {
        new Inter1() {
            @Override
            public void save() {
                System.out.println("实现保存方法");
            }
            @Override
            public void get() {
            }
        }.save();
        new Inter2() {
            @Override
            public void eat() {
                System.out.println("eat()方法");
            }
        }.eat();
        new Inter3().study();
    }
}
interface Inter1{
    void save();
    void get();
}
abstract  class Inter2{
    public void play(){
        System.out.println("玩代码");
    }
    public abstract void eat();
}
class Inter3{
    public void drink(){
        System.out.println("什么是快乐星球");
    }
    public void study(){
        System.out.println("学习赚钱");
    }
}
运行结果：
实现保存方法
eat()方法
学习赚钱