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

　　　　　　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;}
}