java 接口和抽象类学习

抽象类

抽象表示的是这个对象是什么，一个类只能继承一个类（抽象类）（单根继承），但是可以实现多个接口（走路接口，睡觉接口等等）（多实现）。抽象类可做方法声明和实现，子类继承抽象类必须全部实现其抽象方法

抽象类的写法:

//抽象类抽象方法没有方法体，无法直接实例化
//外部抽象类不能有final，static 修饰，final定义的子类不可以有子类
public abstract class abstractclass implements A, B, C {
    //成员变量可以被继承
    public static int i=1；//可以直接被类名.变量调用，可以在抽象类的非抽象方法修改，也可以在子类重写方法修改
    public int b=2；//必须实例化子类，通过子类才可以调用
   //abstract method不能实现，所有的抽象方法必须被子类实现，所以抽象方法不能是private和static
    //只要有抽象方法的类一定是抽象类
   abstract void method1(ServletRequest req, ServletResponse res);
    //非抽象方法可以有实现，也可以被子类重写
    void method2() {
        // Its implementation
        //可以对非final的成员变量赋值
   }
    //静态方法可以被抽象类直接调用，可以被子类继承，不可以被子类重写

    public static void print(){
        System.out.println("Hello World !");
    }
 // other method related to ABC
}

子类继承抽象类

//先执行父类构造再执行子类构造
public class childclsss extends abstractclass {
     //强制覆写
    @override
     public void method1(){
         //todo
     }
     //非抽象方法可以不重写也可以重写
 }

内部抽象类

abstract class A{//定义一个抽象类
    static abstract class B{//static定义的内部类属于外部类
        public abstract void print();
    }
}
class C extends A.B{
    public void print(){
        System.out.println("**********");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        A.B ab = new C();//向上转型
        ab.print();
    }
}

隐藏子类

abstract class A{//定义一个抽象类
    public abstract void m();

    private static class B extends A{//内部抽象类子类，相当于外部类
        //@override
        public void m(){//覆写抽象类的方法
            System.out.println("*** !");
        }
    }

    //静态方法
    public static A getInstance(){
        return new B();
    }

}

public class TestDemo {

    public static void main(String[] args) {

        //此时取得抽象类对象的时候完全不需要知道B类这个子类的存在
        A a = A.getInstance();//向上转型得到B的实例
        a.m();//调用重写之后的B的方法
    }
}

接口类

表示这个对象能做什么，接口只能做方法声明，方法必须由实现类实现

抽象类和接口都不能被实例化。接口是抽象方法的集合。如果一个类实现了某个接口，那么它就继承了这个接口的抽象方法，如果实现了这个接口，那么就必须确保使用这些方法。接口只是一种形式，接口自身不能做任何事情
接口用法：

public interface A {
    //接口成员变量，实现类实例可以调用
    //无构造器
   int i=1//成员变量只能是常量。默认修饰符 public static final无法被修改
    void M1();//成员方法 只能是抽象方法。默认修饰符 public abstract
    void M2();
}

实现类：

public class B implements A{
    void M1(){
        //必须实现
    }
      void M2(){
        //必须实现
    }
     public static void main(String[] args) {
    	System.out.println(""+A.a);
        A testI=new B();
        System.out.println("M1"+testI.a);
        testI.M1();
    }
    
}

差异

接口和抽象类的差异
参数	抽象类	接口
方法实现	可以有默认的方法实现	不存在方法实现
实现	子类使用extends关键字来继承抽象类。如果子类不是抽象类的话，它需要提供抽象类中所有声明的方法的实现。	子类使用关键字implements来实现接口。它需要提供接口中所有声明的方法的实现
构造器	抽象类可以有构造器	接口不能有构造器
与正常类的区别	除了你不能实例化抽象类之外，它和普通Java类没有任何区别	接口是完全不同的类型
main方法	抽象方法可以有main方法可以运行	接口没有main方法，不能运行。
添加新方法	提供默认的实现。不需要改变现在的代码。	往接口中添加方法，必须改变实现该接口的类。

总结

·       有默认实现的方法，使用抽象类

·       实现多重继承，必须使用接口。

·       基本功能频繁变化，使用抽象类。