黑马程序员--Java学习日记之面向对象(多态和匿名内部类)

 　　　------- android培训、java培训、期待与您交流！ ----------





继承,总结:

一.代码块：
   1.代码块的种类：
 1).局部代码块：定义在某个方法中；
 2).成员(构造)代码块：定义在类体中，每次实例化此类对象时被调用；
 3).静态代码块：定义在类体中，第一次实例化此类对象时被调用；
   2.代码块的作用：
 1).跟构造方法一样，用于做一些初始化的操作；
   3.如果同时存在静态代码块、构造代码块、构造方法：
 静态代码块--->构造代码块--->构造方法；
二.继承：
   1.可以将一些相同性质的类中，相同的成员，提取出来，形成一个"概念性的父类"
     子类继承了父类，就拥有了父类允许继承的成员。
   2.使用关键字：extends
   3.继承的特点：
 1).只能单继承；
 2).允许多级继承；
   4.注意事项：
 1).父类中的私有成员不能被继承；
 2).构造方法不能被继承；
 3).不要为了部分功能而去继承；
   5.具有 is a 的关系时，可以使用继承；
   6.this和super的区别：
 1.this指向的本类的对象，可以访问成员变量、成员方法、构造方法
 2.super指向的父类的对象，可以访问父类的变量、成员方法、构造方法；
   7.继承中构造方法的注意事项：
 1.如果父类中有"无参"构造方法时，实例化子类时，JVM会自动调用父类中"无参构造方法"
 2.如果父类中没有"无参构造方法"时，子类的构造方法中，必须显示的使用super去调用父类中
          带参的构造方法。
   8.类的实例化过程：
 1.如果有父类，先处理父类：
 2.如果有静态成员，先处理静态的；
 3.总体过程：
  父类静态成员
  子类静态成员
  父类普通成员变量
  父类的构造代码块
  父类的构造方法
  子类的普通成员变量
  子类的构造代码块
  子类的构造方法
   9.子类成员覆盖父类成员：
 1.子类可以定义和父类相同的"成员变量"：
  this.num:本类的
  super.num:父类的
 2.子类可以定义和父类相同的方法：叫：方法重写
  返回值类型、方法名、形参列表都完全相同；
  子类拥有跟父类相同，或更宽的访问修饰符；
 3.子类可以覆盖父类的静态方法；
三.fianl关键字：
 1.类：表示"最终类"，不能被继承；
 2.成员变量、局部变量：表示拥有最终的值，其值不能被更改；
 3.成员方法：表示最终的方法，不能被重写；

class Phone {  
02.  
03.    // 成员变量  
04.    private String brand ;      // 品牌  
05.    private String color ;      // 颜色  
06.    private int    price ;      // 价格  
07.  
08.    // 构造方法  
09.    public Phone(){}  
10.  
11.    public Phone(String brand , String color , int price){  
12.        this.brand = brand ;  
13.        this.color = color ;  
14.        this.price = price ;  
15.    }  
16.  
17.    // 提供get和set方法  
18.    public String getBrand(){  
19.        return brand ;  
20.    }  
21.  
22.    public void setBrand(String brand){  
23.        this.brand = brand ;  
24.    }  
25.  
26.    public String getColor(){  
27.        return color ;  
28.    }  
29.  
30.    public void setColor(String color){  
31.        this.color = color ;  
32.    }  
33.  
34.    public int getPrice(){  
35.        return price ;  
36.    }  
37.  
38.    public void setPrice(int price){  
39.        this.price = price ;  
40.    }  
41.  
42.}  
43.  
44.// 测试类  
45.class PhoneDemo {  
46.  
47.    public static void main(String[] args){  
48.          
49.        // 创建手机对象方式1  
50.        Phone p = new Phone();  
51.  
52.        // 给成员变量赋值  
53.        p.setBrand("苹果");  
54.        p.setColor("白色");  
55.        p.setPrice(100);  
56.  
57.        // 获取成员变量  
58.        System.out.println(p.getBrand() + "---" + p.getColor() + "---" + p.getPrice());  
59.  
60.        System.out.println("----------------------------------");  
61.  
62.        // 创建手机对象方式2  
63.        Phone p2 = new Phone("三星" , "黑色" , 50);  
64.  
65.        // 获取成员变量  
66.        System.out.println(p2.getBrand() + "---" + p2.getColor() + "---" + p2.getPrice());  
67.    }  
68.}  

多态总结:

一.多态：
 1).父类的引用指向了它的子类的对象；（自动的向上转型）
 2).使用多态时，访问的成员在父类中必须存在，否则编译错误；
  运行时，如果子类成员覆盖父类成员时：
   只有普通成员方法运行的是子类的，其它的都是父类的。
 3).成员变量：编译看左边，运行看左边；
    成员方法：编译看左边，运行看右边；
    静态方法：编译看左边，运行看左边；
 4).多态时，父类的引用不能访问子类特有的成员；
 5).转型的问题：
   class A{}
   class B extends A{}
   class C extends A{}
  A.父类引用指向子类对象：自动向上转型；
   A a = new B();
  B.父类的引用可以强制转换为它所指向的子类的类型；
   B b = (B)a;
  注意：向下转型，要求必须是父类确实指向了那个子类的对象
   如果将a强转为C，会：编译通过，运行时异常：ClassCastException
   C c = (C)a;
  C.可以使用instanceof关键字，先判断，后转型：
   if(a instanceof B){
    B b = (B)a;
   }
二.抽象类：
 1).使用关键字：abstract定义；
 2).抽象类的特点：
  A.不能被实例化；
  B.只能被子类继承；
  C.可以包含：
   成员变量(静态)
   成员方法(静态)
   构造方法
   抽象方法
 3).一个类可以继承自一个抽象类，使用关键字：extends.仍然是单继承；
 4).一个类继承了一个抽象类，那么必须全部重写抽象类中的抽象方法。否则，这个子类
           也必须是个抽象类。

三.接口：
 1).使用关键字：interface定义：
 2).接口的特点：
  A.不能被实例化；
  B.只能用于子类实现。一般子类通过接口来扩展功能。
  C.可以包含：
   成员变量：必须定义为：public static final(静态常量)
   抽象方法：必须定义为：public abstract
 3).子类实现：
  A.使用关键字：implements
  B.一个类可以同时实现多个接口；也可以同时继承自一个父类
   class A extends AbstractA implements IA,IB{
   }
 4).接口和接口之间，是"继承关系"，使用extends关键字。而且可以多继承；

匿名内部类:

一.引用类型的形参和返回值：
 引用类型的形参：
  A.类：实参必须是此类对象的引用，或者是null
  B.抽象类：实参必须是此抽象类的子类的对象的引用。或者是null
  C.接口：实参必须是此接口的子类的对象的引用。或者是null
 引用类型的返回值：
  A.类：返回的，必须是此类对象的引用，或者是null;
  B.抽象类：返回的，必须是这个抽象类的子类的对象的引用，或者是null;
  C.接口：返回的，必须是此接口的子类对象的引用，或者是null.

二.包：
 1.定义包：package
 2.导入包：import
 3.顺序：
  1.package
  2.import
  3.class
 4.package必须放在java文件的第一行有效语句；
 5.package语句在一个java文件中只能有一条；
 6.import语句可以有多条；
 7.import语句可以使用通配符*。只统配这个包下的类，通配这个包下的包；
 8.怎样使用其它包下的类：
  方式一：全名限定：cn.itcast.tools.ArrayTools.getMax();
  方式二：先导包，之后就可以直接使用这个类了。
三.访问修饰符：
 1.四种：public、protected、(默认)、private
 2.修饰类：public 和 (默认)
   修饰成员：四种都可以；
 3.修饰成员的权限：
  1.public :公有，整个项目的所有类都可以访问；
  2.protected:受保护的。包内的其它类可以访问。其它包，只有子类可以访问；
  3.(默认)：包内的其它类可以访问；
  4.private:私有：只能在类的内部访问；
四.内部类：
 1.成员内部类：
  1).同其它成员一样，可以访问外部类中的其它成员；即使是私有的；
  2).实例化一个"成员内部类"的对象：
   A.B b = new A().new B();
  3).成员变量的覆盖：
   class A{
    int num = 10;
    class B{
     int num = 20;
     void show(){
      int num = 30;
      System.out.println(num);//30
      System.out.println(this.num);//20
      System.out.println(A.this.num);//10
     }
    }
   }
 2.局部内部类：
  1).定义在某个方法或其它局部代码内的内部类；
  2).可以获取局部内部类的对象，但此局部内部类，要实现一个外部定义的接口或继承一个父类；
  3).注意：局部内部类可以访问局部变量，但是要求这个局部变量必须被声明为：final的(常量)
   class A{
    int num = 10;
    void show(){
     int num = 20;
     class B{
      void f(){
       System.out.println("num = " + num);
      }
     }
    }
   }
 3.匿名内部类：
  1).定义在局部；
  2).跟局部内部类一样，只是可以省略名字：
   interface IA{
    void fun();
   }
   class A{
    IA show(){
     return new IA(){
      public void fun(){
       System.out.println("子类重写的fun方法");
      }
     }
    }
   }