Java的第七篇文章——面向对象接口（包含了接口、static修饰符、final修饰符、main方法、内部类等知识点）

public interface A {
    public abstract void a1();
    public abstract void a2();
}

public abstract class B implements A {
    public  void a1(){
    }
   // public abstract void a2();
}

/**
 *  笔记本电脑类
 */
public class Computer {
    /**
     *  笔记本电脑,通过USB接口,使用外接设备
     *  方法定义,实现设备的使用
     *  返回值类型 : 这个方法经过运算后的结果的数据类型
     *  参数 : 其实方法的参数,是方法运算过程中的未知数据,才是参数
     *
     *  笔记本电脑,通过USB接口,使用外接设备 这个功能的未知数据,就是外接设备
     *  核心 : 未知设备,都有共同特性 : 满足接口规则
     *
     *  问题 : 这个方法调用 : 传递他什么
     *  参数是引用类,要传递对象,传递接口实现类对象
     */
    public void useUSB(USB usb){
//        USB usb =  new Mouse();
        //接口引用调用方法
        usb.start();
        usb.end();
    }
}

/**
 *  键盘类 : 满足接口标准
 */
public class KeyBoard implements USB{
    @Override
    public void start() {
        System.out.println("键盘工作");
    }
    @Override
    public void end() {
        System.out.println("键盘停止工作");
    }
}

/**
 *  鼠标类 : 接入USB接口工作
 *  满足接口的规则 : 程序中就是实现接口
 */
public class Mouse implements USB{
    @Override
    public void start() {
        System.out.println("鼠标打开开关,按键,滚轮");
    }
    @Override
    public void end() {
        System.out.println("开关关了");
    }
}

/**
 *  定义的USB接口 : 规则指定
 *  接口的规则 : 程序中的抽象方法
 */
public interface USB {
    //设备开始工作
    public abstract void start();
    //设备结束工作
    public abstract void end();
}

public class USBTest {
    public static void main(String[] args) {
        //测试笔记本案例
        //创建笔记本对象
        Computer computer = new Computer();
        //调用笔记本的方法 useUSB
       /* Mouse m = new Mouse();
        computer.useUSB(m);*/
        computer.useUSB( new Mouse() );
        //调用笔记本的方法,传递键盘对象 (USB接口实现类对象)
        computer.useUSB( new KeyBoard());
    }
}

public class Person {
    String name;
    static String country = "中国";
}

public class StaticTest {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.name = "张三";
        Person p2 = new Person();
        p2.name = "李四";
        //使用对象p1修改变量country的值
        p1.country = "美国";
        System.out.println(p2.country);
    }
}

Person.country ;//调用静态成员

public static void main(String[] args) {
    System.out.println(Person.country);
    Person p1 = new Person();
    p1.name = "张三";
    Person p2 = new Person();
    p2.name = "李四";
    //使用对象p1修改变量country的值
    Person.country = "美国";
    System.out.println(Person.country);
}

public class Person {
    String name;
    static String country = "中国";
    /**
     * 静态方法
     */
    public static void eat(){
        System.out.println("人在吃饭" + country);
        System.out.println(name); //错误写法,不允许
    }
}

public static void main(String[] args){}

public final class A{} //这个类A,不能出现子类,如果继承,直接报错
public class B extends A{} //错误,编译错误,最终类不能继承

public class A{
    public final void a(){} //方法不能被子类重写
}
public class B extends A{
    public void a(){} //最终方法,不能重写
}

public static void main(String[] args) {
    /**
    *   Student student 对象存储的是内存地址
    *   final修饰后,固定住的,不可改变是student变量保存的地址
    *   但是,Student对象中的成员,不受影响
    */
    final  Student student = new Student();
    student.age = 20;
    student.age = 30;
    System.out.println(student.age);
    final int[] arr = {1,2,3};//arr变量的值,固定为内存地址,不可改变
    arr[1] = 200;
    show(5);
    }
    public static void show(final int x){
      x = 6; //final修饰,不可改变,报错
    }
}

public class Student {
    final int age ;
    public Student (int age ){
        this.age = age;
    }
   /*public void setAge(int age){
       this.age = age;
   }这样赋值时错误的*/
}

class A{ //外部类,封闭类
    class B{} //内部类,嵌套类
}

class 大楼{
    class 电梯{}
}

//外部类
public class Outer {
    public void outer(){
        System.out.println("外部类的方法outer");
    }
    //内部类
    public class Inner{
       public void inner(){
           System.out.println("内部类的方法inner");
       }
    }
}

public static void main(String[] args) {
    //调用内部类的方法inner()
    Outer.Inner oi = new Outer().new Inner();
    oi.inner();
}

class A{
    public void a(){
        class B{} //局部内部类
    }
}

public class Outer {
    /**
     *  Inner类,是方法Outer的局部
     *  依然方法,才能被外界访问
     */
    public void outer(){
        class Inner{
            public void inner(){
                System.out.println("局部内部类的方法!!");
            }
        }
        //方法,建立对象
        //因为是和Inner同级，所以可以直接Inner inner = new Inner()来创建对象
        Inner inner = new Inner();
        inner.inner();
    }
}

public static void main(String[] args) {
    //调用内部类的方法inner()
    //不能直接调用
    Outer outer = new Outer();
    outer.outer();
}

new 接口或者父类(){
    //重写抽象方法
};

public interface MyInter {
    public abstract void inter();
    public abstract void inter2();
}

public class InnerClassTest {
    public static void main(String[] args) {
        //匿名内部类,简化书写,不写实现类
        //同时调用多个重写方法
        /*
         *  new MyInter(){}; 是接口实现类的匿名对象
         * 多态 : 接口 变量 = 实现类对象
         */
       MyInter my =  new MyInter(){
            @Override
            public void inter() {
                System.out.println("实现类实现接口重写方法");
            }
            @Override
            public void inter2() {
                System.out.println("实现类实现接口重写方法2222");
            }
        };
       my.inter();
       my.inter2();
    }
}

public class InnerClassTest {
    public static void main(String[] args) {
        new MyInter(){
            @Override
            public void inter() {
                System.out.println("你好美！！！");
            }
            @Override
            public void inter2() {
                System.out.println("你好帅！！！");
            }
        }.inter();
    }
}