JAVA抽象类,接口,内部类 JAVA抽象类,接口,内部类详解

【修饰符】 abstract 返回值类型 methodName（形参列表）;
//示例:
public abstract void runWay();//定义一个行进的方法

public abstract class Piece{}//定义一个棋子类

//定义抽象父类Piece
public abstract class Piece{
    /**
    *定义棋子的行进方法
    */
    public abstract void runWay();
    /**
    *定义棋子进攻的方法
    */
    public void attack() { 
        System.out.println("吃掉下面的棋子");
    }
}
//Piece的子类Horse
public class Horse extends Piece{
    /**
    *实现父类中定义的抽象方法
    */
    public void runWay() {
        System.out.println("按照日字格行进！");
    }
}
//Piece的子类Cannon
public class Cannon extends Piece{
    /**
    *实现父类中定义的抽象方法
    */
    public void runWay() { 
        System.out.println("按照直线方式行进！");
    }
}

【public】interface 接口名 extends 父接口1,父接口2{
    //零到多个常量定义
    //零到多个抽象方法定义
}

interface DBobjectType{
    //对于在接口中定义的成员变量，用或不用public static final，意义都是相同的
    public static final int ROOT=0;
    public static final int DATABASE=1; 
    int TABLE=2; 
    int COLUMN=3;
    int INDEX=4;
}

public interface DataConnection{
    /**
    *定义获取数据库连接的方法*/
    public abstract void getConnection();
    /**
    *定义关闭数据库连接的方法，在接口中是否使用public abstract意义相同*/
    void close();
}

public interface InterA{//定义接口A
    void a();
}
public interface InterB{//定义接口B
    void b();
}
public interface Inter extends InterA,InterB{//定义接口Inter继承A、B
    voidc();
}

public interface InterA {
  void a();
}
public class InterAImpl implements InterA
{
    @Override
    public void a(){
        System.out.println("将接口InterA中定义的抽象方法进行实现！");
    }
}

public interface DBobjectType {
    public static final int ROOT =0; 
    public static final int DATABASE =1;   
    int TABLE=2;
    int COLUMN=3;
    int INDEX=4;
}
public interface DataConnection{
    /**
    *定义获取数据库连接的方法
    */
    public abstract void getConnection();
    /**
    *定义关闭数据库连接的方法，在接口中是否使用publicabstract意义相同
    */
    void close();
}
public class ConnectionImpl implements
    DBobjectType,DataConnection {
    @Override
    public void getConnection() {
        System.out.println("获取一个连接对象！");
    }
    @Override
    public void close() {
        System.out.println("将连接进行关闭！");
    }
    public static void main(String[]args){
        ConnectionImpl impl=new ConnectionImpl();
        //直接使用从DBobjectType继承过来的成员变量定义
        System.out.println("数据对象类型："+ConnectionImpl.ROOT);
        impl.getConnection();
    }
}

//定义接口规范
public interface DataConnection{
    /**
    *定义获取数据库连接的方法*/
    public abstract void getConnection();
    /**
    *定义关闭数据库连接的方法
    */
    public abstract void close();
}
//定义不同数据库的实现类MySql
public class MySqlConnection implements DataConnection {
    @Override
    public void getConnection() {
        System.out.println("获取MySql数据库的连接。。。");
    }
    @Override
    public void close() {
        System.out.println("关闭MySql数据库的连接。。。");
    }
}
//定义不同数据库的实现类Oracle
public class OracleConnection implements DataConnection {
    @Override
    public void getConnection(){
        System.out.println("获取Oracle数据库的连接。。。");
    }
    @Override
    public void close() {
        System.out.println("关闭Oracle数据库的连接。。。");
    }
}
//定义不同数据库的实现类SqlServer
public class SqlServerConnection implements DataConnection {
    @Override
    public void getConnection() {
        System.out.println("获取SqlServer数据库的连接。。。");
    }
    @Override 
    public void close() {
        System.out.println("关闭SqlServer数据库的连接。。。");
    }
}

public class DiningRoom {
    private String egg="鸡蛋";
    class Cook { 
        public void makeFood() {
            //使用了外部类DiningRoom中定义的私有成员egg
            System.out.println("厨师使用"+egg+"，做了一份炒鸡蛋！");
        }
    }
    /**
    *DiningRoom类对外提供的做炒鸡蛋的功能*实际该功能是由内部类Cook来执行的
    */
    public void fireEgg(){
        new Cook().makeFood();
    }
}

public class DiningRoom {
    private String egg="鸡蛋";
    private Cook cook=new Cook();
    class Cook {
        public void makeFood() {
            //使用了外部类DiningRoom中定义的私有成员egg
            System.out.println("厨师使用"+egg+"，做了一份炒鸡蛋！");
        }
    }
    /**
    *DiningRoom类对外提供的做炒鸡蛋的功能*实际该功能是由内部类Cook来执行的
    */
    public void fireEgg(){ 
        this.cook.makeFood();
    }
}

public class Factory {
    public static String noodle="面条";
    public static String dumplings="水饺";
    private String chicken="鸡肉";
    public void madamFood(String food){
        System.out.println("厂长吃的是自己夫人做的饭！"+food);
    }
    public static void diningFood(String food){
        System.out.println("工人吃的是食堂做的饭！"+food);
    }
    static class DiningRoom {
        public static void eat(){
        	diningFood(Factory.noodle);
        }
        public void managerEat() {
            //编译报错，在静态内部类中，即使是非静态的成员
            //也不能访问外部类的非静态的成员
            madamFood("abc");
        }
    }
}

public void run() {
    //定义一个局部内部类，作用范围更小，在方法外根本无法访问
    class InnerTest {
        public int num2=5;
        public void run(){
            System.out.println(num2);
        }
    }
    InnerTest it=new InnerTest();
    it.run();
}

new 父类构造器|实现接口 (){
    //匿名内部类的类体部分
}

public class Test { 
    public static void main(String[]args) {
        Integer [] nums={1,3,10,21,14,5,27};
        //sort方法需要接收一个Comparator排序器对象，Comparator是接口类型
        Arrays.sort (nums,new Comparator <Integer>(){
            @Override 
            public int compare (Integer int1,Integer int2){ 
                if(int1>int2){
                    return-1;               
                }else {
                    return1;
                }
            }
        });
        System.out.println(Arrays.toString(nums));
    }
}