java面向对象 11 抽象类

 

 

       抽象类：

                   1. abstract修饰符可以用来修饰方法也可以用来修饰类，如果修饰方法，那么该方法就是抽象方法；

                       如果修饰类，那么该类就是抽象类。

                   2. 抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明抽象类。

                   3. 声明为abstract的类不能被实例化，为了实例化，该类必须作为父类，子类可以通过继承它，

                      然后添加自己的属性。

                   4. 抽象类，不能使用new关键字来创建对象，它是用来让子类继承的。

                   5. 抽象方法，只方法的声明，没有方法的实现(没有方法体)，它是用来让子类实现的。

                   6. 子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。

                   7. 抽象类中不一定要包含抽象方法，但是定义了抽象方法的类必须是抽象方法。

                          注意：与final类和final方法相反，abstract类必须被继承，abstract抽象方法必须被重写。

abstract class A
{
    abstract void callme();
    void metoo()
    {
        System.out.println("inside A smetoo");
    }
}
class B extends A
{
    @Override
    void callme()
    {
        System.out.println("抽象");
    }
}
class As
{
    public static void main(String[] args) 
    {
        A a=new B();
        a.callme();
        a.metoo();
    }
}
----------------------------

interface Bank2
{
    double oneYearRate=0.0178;
    double interestRate=0.0078;
    double count();
    abstract double a();
}
class OneYearFixed2 implements Bank2
{
    double savedq;
    public void setSavedq(double savedq)
    {
        this.savedq = savedq;
    }
    public double getSavedq()
    {
        return (this.savedq);
    }
    public double count()
    {
        return savedq*(1+oneYearRate);
    }
  public void s()
  {
      System.out.println("抽象a");
  }
  public double a()
  {
      return -1;
  }
​
}
class OneYear2 implements Bank2 
{
    double savehq;
    double b;
​
    public void setSavehq(double savehq) 
    {
        this.savehq = savehq;
    }
​
    public double getSavehq()
    {
        return (this.savehq);
    }
​
    public double count() 
    {
        return savehq * (1 + interestRate);
    }
​
    public double seta(double b)
    {
        return this.b=b;
​
    }
​
    public double geta() 
    {
        return (this.b);
    }
​
    public double a()
    {
        return b * b;
    }
}
public class TestBank2
{
    public static void main (String[] args)
    {
//        OneYearFixed2 oyf2=new OneYearFixed2();
//        oyf2.setSavedq(10000);
//        System.out.println ("本金1万元存1年定期后，总金额为："+oyf2.count());
//        OneYear2 oy2=new OneYear2();
//        oy2.setSavehq(10000);
//        System.out.println ("本金1万元存1年活期后，总金额为："+oy2.count());
        OneYear2 oneYear2=new OneYear2();
        oneYear2.seta(5);
        System.out.println(oneYear2.a());//25
                                          
    }
}

----------------------------------

package demo06;
​
public abstract class Action
{
        //String name="dj.";
​
    //abstract 抽象类:类 需要继承（extends）单继承， （但接口可以多继承）
​
        //约束~有人帮我们实现~
        //abstract ,抽象方法，只有方法名字，没有方法的实现！
        public abstract String doSome(String name);
    /*
    1.不能new这个抽象类只能靠子类去实现它，约束！
    2.抽象类里面可以写普通方法~
    3.抽象方法必须在抽象类中~
    抽象的抽象：约束~
    //思考题？ new，存在构造器吗？
    //抽象存在的意义  抽象出来~ 提高开发效率
​
     */
​
}

package demo06;
//抽象类的所有的方法，继承了它的子类，都必须要实现它的方法~ 除非子类也是抽象类abstract~
public  class A extends Action
{
    //String name;
    public  String doSome(String name)
    {
        return name;
        //System.out.println("抽象");
    }
​
}

package demo06;
//abstract 抽象类:类 需要继承（extends）单继承， （但接口可以多继承）
public  class Application
{
    public static void main(String[] args)
    {
        new A();
        String name="fdjlk";
        new A().doSome(name);
        System.out.println(new A().doSome(name));
       // A.doSome();
​
    }
}