Java基础之八

回顾：  
1.重写override
2.重写与重载的区别
3.package和import
4.访问控制修饰符
5.static
6.final






正课：
1.static final常量
2.抽象方法
3.抽象类
4.接口






一、static final常量：---控制修饰符只能用public、默认的两种，一般情况都用public     public static final...
   1.static final修饰的成员变量成为常量，用大写字母表示
   2.存在方法区中，访问时用类名.常量名，不能被改变
   3.常量声明的同时必须初始化
   4.static final常量是在"编译期"被替换的
    class Aoo{
      public static int b = 3.1415926;//静态变量
      public static final int A = 3.1415926;//常量  ----三个修饰词的位置可以互换，但建议public static final这么写
    }
    class Boo{
       main方法中：
      //先加载Aoo.class到方法区；静态变量b也存在方法区；到方法区去获取b的值并输出
      System.out.println(Aoo.b);
      //***编译时****被直接替换成具体的值，***效率高***；相当于System.out.println(3.1415926);
      System.out.println(Aoo.A);
    }


二、抽象类和方法  ----不完整 
   1).抽象方法
     1、由abstract修饰      ====修饰词只能用public和默认
     2、只有方法的定义，没有方法的具体实现（没有方法体即大括号，直接以分号结尾）
        abstract class Shape{//抽象类，不完整
            double c;
   abstract double area(); ----抽象方法，不完整
        } 
   2).抽象类
     1、由abstract修饰
     2、包含抽象方法的类必须是抽象类
     3、抽象类不能被实例化---不能创建对象new Shape()；但可以用来声明引用的类型Shape s（但可以作为一种类型声明变量Shape s）;
     4、抽象类是需要被继承的，子类：                         ====基于这一点final和abstract不能同时使用
        a.重写抽象类中的*所有*抽象方法  ---这样子类就能创建对象，才有意义
 不包含抽象方法的类，也可以声明为抽象类  ----个人意愿
b.也可以声明为抽象类，但子类也没意义了 ---一般不这么做
     5、抽象类的意义：
        a.封装子类共有的成员变量和方法，被子类共用
b.为所有子类提供了一种统一的类型---向上造型Shape s = new 子类类名();
c.包含抽象方法，为所有子类提供一个统一的入口    =======最重要
三、接口----可看成是特殊的抽象类
   1).是一个标准、规范
      遵守了这个标准，就能干某件事 ---API之后
   2).由interface定义      ----与类是并列关系          只能用public和default修饰（默认其实也是public）
   3).只能包含常量和抽象方法
      interface Inter1{
         public static final int NUM=5;
public abstract void show();
public void show();
double PI = 3.1415926;//默认public static final
void show();//默认public abstract
int a;//编译错误，默认为常量，但未初始化
void study(){}//编译错误，有方法体
      }
   4).接口不能被实例化     不能创建对象new Shape()；但可以用来声明引用的类型Shape s;
   5).接口是需要被实现/继承的，实现类/子类：class Aoo implements Inter1{}
      必须重写接口中所有的抽象方法
   6).一个类可实现多个接口，用逗号隔开，该类必须重写所有抽象方法
      若又继承又实现，要先继承后实现
     
      类和类 -----extends
      接口与接口----extends
      类与接口----implements
    
      interface Inter1{    
          void show();// public abstract
      }
      interface Inter2{    
          void study();// public abstract
      }
      abstract class Aoo{
          abstract void work();
      }
      class Boo extends Aoo implements Inter1,Inter2{
          public void show(){}
 public void study(){}
 void work(){}
      }
   7).接口可以继承接口
       interface Inter1{    
          void show();
      }
      interface Inter2 extends Inter1{ //接口可以继承接口  
          void study();
      }
      class Aoo implements Inter2{Aoo是Inter2的实现类
          public void show(){}
 public void study(){}
      }
      Inter2 o2 = new Aoo();//向上造型
      Inter1 01 = new Aoo();//向上造型 
    =====================================================
    现实生活中的接口：
    1、电脑厂商做了USB接口          ---制定标准、规范
       U盘、鼠标、摄像头等          ---遵守标准、规范
    2、国家对商品房                 ---制定标准、规范
       国家对家具、家电             ---制定标准、规范
       开发商、家具家电厂商         ---遵守标准、规范
    3、银行                         ---制定标准、规范
       银行卡---                    ---遵守标准、规范
       
今天任务：
1.创建oo.day06，要求把今天银行卡系统的代码--重写一次


周末任务：
1.自学
  抽象类与接口的区别是什么？
  何时用抽象类？何时用接口？
2.一周的经典案例重做一次





回顾：
1.static final常量
  不能改，必须声明的同时初始化，类名.来访问
  建议所有字母大写
  在编译时被自动替换成具体的数值
2.抽象方法：
  abstract修饰
  只有方法的定义，没有方法的具体实现
3.抽象类：
  abstract修饰
  包含抽象方法的类必须是抽象类
  不能被实例化
  需要被继承，子类：要么也声明为抽象类，要么重写所有的抽象方法
  意义：
  封装共有，给所有子类提供了一种统一的类型
  包含抽象方法，为所有子类提供统一的入口
4.接口：
  标准、规范
  interface修饰
  只能包含常量和抽象方法
  不能被实例化
  需要被实现，实现类：必须重写所有的抽象方法
  一个类可以实现多个接口， 
     若又实现又继承，要先继承后实现
  接口可以继承接口


================================
设计原则：
1.所有子类所共有的封装在父类中
2.所有子类行为一样---普通方法
  所有子类行为不一样---抽象方法
3.符合"既是也是"原则，使用接口
================================
正课：
1.多态
2.内部类
3.面向对象总结


一、多态
   1.多态的意义：
     a.同一类型的引用在指向不同的对象时(父类类型（抽象类）引用指向不同子类对象)，会有不同的实现
       ---行为的多态：cut(),run()---抽象方法、重写
     b.同一个对象(实现类的对象)被造型为不同的类型（不同接口类型）时，有不同的功能（行为）
       ---对象的多态：我---不同接口类型时，我的行为是不一样的（儿子、老公、学生）
   2.向上造型：
     a.父类型的引用指向子类的对象
     b.能造型成的类型：
       父类型、其实现的接口类型
     c.能点出来什么，看引用的类型（调用重写方法时能点出来什么，看对象类型）
     向上造型之后，能点出来的东西（少了或者相同）---所以才有强制类型转换
   3.强制类型转换，成功的条件：
     a.引用所指向的对象，就是该类型
       class Aoo{}
       interface Inter{}
       class Boo extends Aoo implements Inter{}
       class Coo extends Aoo{}
       Aoo o1 = new Boo();//向上造型（自动类型转换）
       if(o1 instanceof Boo){//True，o1指向的对象为Boo
       }
       Boo o2 = (Boo)o1;o1所指向的对象Boo就是Boo类型
     b.引用所指向的对象，实现了该接口
       Inter o3 = (Inter)o1;//o1所指向的对象Boo实现了Inter接口
       Coo o4 = (Coo)o1;//编译没错，但运行时会报错：类型转换异常ClassCastException
       if(o1 instanceof Coo){//false，o1指向的对象为Boo，其与Coo无关系
          Coo o4 = (Coo)o1;
       }


多态总结：
1，使用父类类型的引用指向子类的对象
2，改引用只能调用父类中定义的方法，不能调用子类中独有的方法
3，如果子类中重写了父类中的一个方法，那么在调用该方法的时候，将会调用子类中的这个方法
4，在多态中，子类可以调用父类中的所有方法




二、内部类
   1.成员内部类    ---单独使用的几率不大
     a.类中套类，外面的叫外部类，里面的叫内部类
     b.内部类通常只服务于外部类，对外不具备可见性
     c.内部类对象通常只在外部类中创建（构造方法或者其他方法中）
     d.内部类可以直接访问外部类的成员及方法（包括私有的）
       为什么能访问：因为内部类有个隐式的引用指向了创建它的外部类：外部类名.this.
   2.匿名内部类    
     a.若想创建一个类的对象（通常这个类需要实现某个接口或继承某个类），并且对象只被创建一次，此时该类不必命名，称之为匿名内部类
       注意：这个类必须是子类
       SuperType obj = new SuperType (…) {
       … … …
       }; 
       第一个SuperType为用匿名类所实现的接口或所继承的父类类型声明的引用。
       第二个SuperType为匿名类所要实现的接口或继承的父类
       小括号（）中为构造方法参数；大括号中为匿名中定义的成员变量或方法
     b.匿名内部类中若想访问外部的变量，该变量必须是final的 
       这种内部类可以访问方法体中的局部变量，但是，该局部变量前必须加final修饰符。
       常见面试题：
         问：内部类有自己独立的.class吗？
答：有


三、面向对象总结
    宏观上：
    面向对象的三个特点：
      1.封装：使用private修饰我们的属性，使用public来修饰方法  封装的作用：提高数据安全性，操作简单
        1).类：封装对象的属性和行为
2).方法：封装的是具体的实现过程
3).访问修饰符：封装的是访问的权限
      2.继承：
        1).作用：避免代码重复，有利于代码的复用
2).父类：所有子类所共有的属性和行为
  子类：子类所特有的属性和行为
3).子继承父后，子具有：父+子
4).单一继承、传递性
      3.多态：
        1).意义：
  同一类型的引用在指向不同的对象时，会有不同的实现
  同一个对象被造型为不同的类型时，有不同的功能
2).向上造型、强制类型转换、instanceof
3).多态的表现形式（也是重写和重载的共同点：都是多态的表现形式）
  a.重写
  b.重载