Unit05 - 抽象类、接口和内部类（上）

时间：2021-08-13 11:28:19

　　　　　　Unit05 - 抽象类、接口和内部类（上）　　　　　　

1.static final常量:
  1)必须声明同时初始化
  2)通过类名来访问，不能被改变
  3)建议:常量名所有字母都大写(多个单词间用_)
  4)在编译时被自动替换为具体的值，效率高

2.抽象方法:
  1)由abstract修饰
  2)只有方法的定义，没有方法具体的实现(大括号都没有)

3.抽象类:
  1)由abstract修饰
  2)包含抽象方法的类必须是抽象类
    不包含抽象方法的类也可以声明为抽象类----我乐意
  3)抽象类不能被实例化
  4)抽象类是需要被继承的，子类:
    4.1)重写所有抽象方法---建议
    4.2)也声明为抽象类-----不常这样做
  5)抽象类的意义:
    5.1)封装子类所共有的属性和行为-------继承父类--父类的意义
    5.2)为所有子类提供了一种统一的类型---向上造型--父类的意义
    5.3)可以包含抽象方法，为所有子类提供了统一的入口
        子类的具体实现不同，但入口的定义是一致的

4.接口:
  1)是一种标准、规范(制定方)
    遵守了这个标准就能干某件事---------API后
  2)是一种数据类型(引用类型)
  3)由interface定义，只能包含常量和抽象方法
  4)接口不能被实例化
  5)接口是需要被实现(implements)的，实现类:
      必须重写接口中的所有抽象方法
  6)一个类可以实现多个接口，
    若又继承又实现时，应先继承后实现
  7)接口可以继承接口

接口例子：
interface Inter1{
  public static final int NUM = 5;
  public abstract void show();
  int COUNT = 6; //系统默认加了public static final
  void say(); //系统默认加了public abstract

int number; //编译错误，常量必须声明同时初始化
  void test(){} //编译错误，抽象方法不能有方法体
}

abstract class Shape{ //抽象类---不完整
  double c; //周长
  abstract double area(); //抽象方法---不完整
}
class Square extends Shape{
  double area(){ //重写抽象方法--变不完整为完整
    return 0.0625*c*c;
  }
}
class Circle extends Shape{
  double area(){
    return 0.0796*c*c;
  }
}
class Six extends Shape{
  double area(){
    return 0.0721*c*c;
  }
}

static final常量,优点:效率高

package oo.day05;

//static final常量

public class StaticFinalDemo {

    public static void main(String[] args) {

        System.out.println(Aoo.PI); //通过类名点来访问

        //Aoo.PI = 3.1415926; //编译错误，常量值不能被改变

        //1.加载Boo.class到方法区中

        //2.将num存储在方法区中

        //3.到方法区中获取num的值并输出

        System.out.println(Boo.num);

        //相当于System.out.println(8);　　效率高

        System.out.println(Boo.COUNT);

    }

}

class Boo{

    public static int num = 5; //静态变量

    public static final int COUNT = 8; //常量

}

class Aoo{

    public static final double PI = 3.14159;

    //public static final int NUM; //编译错误，必须声明同时初始化

}

扩展知识：
int COUNT = 6; //系统默认加了public static final
  void say(); //系统默认加了public abstract

练习抽象类程序，求一组图形中的最大面积

package oo.day05;

//求一组图形中的最大面积

public class ShapeTest {

    public static void main(String[] args) {

        //Shape s = new Shape(); //抽象类不能被实例化

        Shape[] shapes = new Shape[4]; //创建Shape数组对象

        shapes[0] = new Square(1);

        shapes[1] = new Square(2);

        shapes[2] = new Circle(1);

        shapes[3] = new Circle(2); //大

        maxArea(shapes);

    }

    //找最大面积

    public static void maxArea(Shape[] shapes){

        double max = shapes[0].area(); //最大面积

        int maxIndex = 0; //最大面积下标

        for(int i=1;i<shapes.length;i++){

            double area = shapes[i].area();

            if(area>max){

                max = area;

                maxIndex = i;

            }

        }

        System.out.println("最大面积:"+max+"，所在下标为:"+maxIndex);

    }

}
//个人理解：抽象类就是一个入口，然后被其他类继承，通过抽象类，来调用自己定义的类
abstract class Shape{ //抽象类里，方法也必须是抽象方法

    protected double c; //周长

    public abstract double area(); //抽象方法，不能有{}区域

}

//抽象类下有几个方法，就要重写几个，否则语法会报错
class Square extends Shape{

    public Square(double c){

        this.c = c;

    }

    public double area(){ //重写抽象方法

        return 0.0625*c*c;

    }

}

class Circle extends Shape{

    public Circle(double c){

        this.c = c;

    }

    public double area(){ //重写抽象方法

        return 0.0796*c*c;

    }

}

接口基础应用演示

package oo.day05;

//接口的演示

public class InterfaceDemo {

    public static void main(String[] args) {

        //Inter6 o1 = new Inter6(); //编译错误，接口不能被实例化

        Inter6 o2 = new Foo(); //向上造型

        Inter5 o3 = new Foo(); //向上造型

    }

}

//接口间的继承

interface Inter5{

    void show();

}

interface Inter6 extends Inter5{

    void say();

}

class Foo implements Inter6{

    public void say(){}

    public void show(){}

}

//接口的多实现

interface Inter3{

    void show();

}

interface Inter4{

    void say();

}

abstract class Doo{　　　　　　//这里是抽象类
abstract void test();

}

class Eoo extends Doo implements Inter3,Inter4{

    public void show(){}

    public void say(){}

    void test(){}

}

//接口的实现

interface Inter2{

    void show();

    void say();

}

class Coo implements Inter2{

    public void show(){}

    public void say(){}

}

//接口的语法

interface Inter1{

    public static final double PI = 3.14159;

    public abstract void show();

    int COUNT = 5; //默认public static final

    void test(); //默认public abstract

    //int num; //编译错误，常量必须声明同时初始化

    //void say(){} //编译错误，抽象方法不能有方法体

}

接口框架演示，银联卡系统

package oo.day05;

//银联卡系统

public class UnionPayTest {

    public static void main(String[] args) {

        ICBCImpl card1 = new ICBCImpl(); //工行卡

        ICBC     card2 = new ICBCImpl(); //工行卡

        UnionPay card3 = new ICBCImpl(); //银联卡--工行卡

    }

}

interface UnionPay{ //银联接口

    public double getBalance(); //查询余额

    public boolean drawMoney(double number); //取款

    public boolean checkPwd(String input); //检查密码

}

interface ICBC extends UnionPay{ //工行接口

    public void payOnline(double number); //在线支付

}

interface ABC extends UnionPay{ //农行接口

    public boolean payTelBill(String phoneNum,double sum); //支付电话费

}

class ICBCImpl implements ICBC{ //工行卡

    public double getBalance(){return 0.0;}

    public boolean drawMoney(double number){return false;}

    public boolean checkPwd(String input){return false;}

    public void payOnline(double number){}

}

class ABCImpl implements ABC{ //农行卡

    public double getBalance(){return 0.0;}

    public boolean drawMoney(double number){return false;}

    public boolean checkPwd(String input){return false;}

    public boolean payTelBill(String phoneNum,double sum){return false;}

}

相关文章