Java_总结八（抽象类与接口）

一、抽象类

　　抽象类的定义及使用规则：

　　　　--包含一个抽象方法的类必须是抽象类

　　　　--抽象类和抽象方法都要使用 abstract 关键字声明

　　　　--抽象方法只需声明而不需要实现

　　　　--子类继承抽象类，子类（如果不是抽象类）必须重写抽象类中的全部抽象方法

 

　　抽象类的定义格式：

        abstract class 抽象类名称{
            属性;
            
            访问权限 返回值类型 方法名称(参数){            //普通方法
                [return 返回值];
            }
            
            访问权限 abstract 返回值类型 方法名称(参数);    //抽象方法
            //在抽象方法中是没有方法体的
        }

        abstract class K{            //抽象方法不能用final修饰，不然子类无法继承，那抽象类也就没意义了            
            private String name;
            public void a() {        //普通方法
                System.out.println("普通方法");
            }
            public abstract void b(); //抽象方法，抽象方法不要用private去修饰，不然子类无法继承和重写抽象方法，就变成了死方法
        }

 

　　类如何继承抽象类：　

        class Y extends K{

            @Override
            public void b() {//继承抽象类，（如果本类不是抽象类）必须实现抽象方法
                System.out.println("我在这里重写了抽象方法");
            }    
        }

 

　　注意点：

　　　　（1）抽象类有构造方法

　　　　（2）但是抽象类不能被实例化，因为抽象类的抽象方法没有方法体（有点牵强）

 

二、接口

　　--可以理解为一种特殊的类

　　--由全局常量和公共的抽象方法组成

　　--接口中抽象方法必须定义为 public 访问权限（如果不写 public，则默认为 public，而不是default）

 

　　接口的定义格式：

        interface 接口名称{
            全局常量;
            公共的抽象方法;
        }

        interface G{
            public static final String NAME = "小明";//全局常量，public static final 可以简化不用写
            public abstract void print();//公共的抽象方法，public abstract 可以简化不写
            public abstract String getInfo();//公共的抽象方法
        }

 

 

　　普通类如何实现接口：（类可以一次实现多个接口）

        interface G{
            public abstract void print();
        }
        interface J{
            public abstract void getInfo();
        }

        class H implements G,J{

            @Override
            public void getInfo() {        //实现J接口的方法
                // TODO Auto-generated method stub
                
            }

            @Override
            public void print() {        //实现G接口的方法        
                // TODO Auto-generated method stub
                
            }

        }

 

 

 

　　抽象方法实现接口：

        interface G{
            public abstract void print();
        }
        interface J{
            public abstract void getInfo();
        }

        abstract class L implements G,J{
            public abstract void b(); //抽象类实现接口不需要重写接口方法
        }

 

　　普通类如何继承类又实现接口：（顺序---先继承再实现）

        interface G{
            public abstract void print();
        }
        interface J{
            public abstract void getInfo();
        }
        class P {
            
        }
        class W extends P implements G,J{ //先继承再实现（绝不能先实现再继承）

            @Override
            public void getInfo() {
                // TODO Auto-generated method stub
                
            }

            @Override
            public void print() {
                // TODO Auto-generated method stub
                
            }
            
        }

 

　　接口可以继承多个接口：

        interface G{
            public abstract void print();//公共的抽象方法
        }
        interface J{
            public abstract void getInfo();//公共的抽象方法
        }
        interface O extends G,J{
            public abstract void sum();
        }