抽象类

1.抽象类的的概念.

普通类可以直接实例化对象

抽象类是指在普通类的结构里面增加抽象放啊发的组成部分。

抽象类的方法没有{} 结构体，并且需要有abstract关键字定义

范例：

abstract class A{
    public void fun(){ 
        System.out.print("ordinary methods") ;
    }
    public abstract void print() ; //abstract methods
}
public class Test{
    public static void main(String args[]){
        A a = new A() ;  //      cannot instantiate
    }
}

使用原则：

1.抽象类必须要有子类

2.子类必须覆写抽象类中的全部抽象方法（）；

３.抽象类的对象实例化需要依靠子类完成，采用向上转型的方式处理。

abstract class A{  //abstract class
    public void fun(){ 
        System.out.print("ordinary methods") ;
    }
    public abstract void print() ; //abstract methods
}
class B extends A{    // a subclass can only inherit an abstract class
    public void print(){
        System.out.println("Hello world") ;
    }
}
public class Test{
    public static void main(String args[]){
        A a = new B() ;  //      cannot instantiate
        a.print() ;
    }
}

 

注意：子类必须覆写抽象类的方法

abstract class A{  //abstract class
    public void fun(){ 
        System.out.print("ordinary methods") ;
    }
    public abstract void print() ; //abstract methods
}
class B extends A{    // a subclass can only inherit an abstract class
   }
public class Test{
    public static void main(String args[]){
              
    }
}

 

 

 

限制：

抽象类不能用fanal定义

抽象类外部的抽象类不能使用static声明，内部抽象类可以使用static声明，用static修饰的内部类就相当于外部类，继承时候用外部类.内部类{}。

代码如下：

abstract class A{
    static abstract class B{
        public abstract void print() ;
    }
}
class C extends A.B{
    public void print(){
        System.out.println("%SSSSS%%") ;
    }
}
public class Test{
    public static void main(String args[]){
       A.B ab   = new C() ;  //向上转型
    }
}

 

 

 

**********************************************************************

对于抽象类中有static修饰的方法也是可以不实例化对象直接调用。。

abstract class A{
    public static void print(){
        System.out.print("Hello world") ;
    }
}
public class Test{
    public static void main(String args[]){
        A.print() ;
    }
}

如果不想让外界知道 B 的存在那么可以内部抽象类子类。在系统类库之中比较多，为用户隐藏不需要知道的类。

abstract class A{
    public abstract void print() ;
    private static class B extends A{
        public void print(){
            System.out.println("Hello world") ;
        }
    }
    public static A getInstance(){
        return new B() ;
    }
    
}
public class Test{
    public static void main(String args[]){
        A a = A.getInstance() ;
        a.print() ;
    }
}

 

一个很有意思的代码：

 

abstract class A{
    public A(){
        this.print() ;
    }
    public abstract void print() ;
}
class B extends A{
    private int a = 100 ;
    public B(int a ){
        this.a = a ;
    }
    
    public void print(){
        System.out.println("a = " + a) ;
    }
}
public class Test {
    public static void main(String args[]){
        new B(30) ;
    }
}

运行结果  a  =   0  ；

1.执行构造函数

2.执行父类构造

3.调用print（）方法，

4.执行覆写后的方法

此时

a没有初始化内容，a的值是默认值。所以a=0