Java面向对象及关键词（下）

this

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

*两种用法：

      1） 引用当前对象:

             *）this 保存当前对象的内存地址（当前对象：正在调用的对象）

             *）用this调用当前对象 的成员： this.name    this.toString()

 

       2）构造方法之间调用:

        *)目的：减少代码的重复

        *）一般从参数少的方法调用参数多的方法，在参数多的方法中编码，集中处理参数的数据

       *）this（....）必须是构造方法首行代码

 

*方法重载：方法名相同，方法参数不同

 

继承

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

*作用：代码重用、复用

*主要继承的是可见成员，不继承：构造方法  、不可见成员、静态成员；

*单继承：1）一个子类只能有一个父类；

                  2）一个父类可以有多个子类；

*创建子类对象：1)先创建父类对象，执行父类构造方法

                              2）再创建子类对象，执行子类构造方法

                                         *）两个对象绑定在一起，整体作为一个子类对象

                                        *）调用成员时先从子类中调用，子类中没有再到父类中调用

*创建子类对象执行父类构造方法：

                              1）默认执行父类无参构造方法    eg：super（）                             

                              2）手动调用父类有参构造方法   eg：super（参数）

 

方法重写 OverRide

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

需要方法重写的情况：

                           1）从父类继承的方法，不满足子类的需要，可以在子类中重写这个方法

                           2）在重写的方法中，可以调用父类同一个方法的代码        eg：super.toString()

 

Super

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

super的两种用法：

                          *) 重写方法时，调用父类中同一个方法    super.toString();

                         *)子类构造方法中，手动调用父类构造方法   super（参数），但必须是首行代码

 

多态

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

*作用：保持一致的类型

*类型转换

               1）向上转型：子类对象转型成父类对象，但向上转型后只能调用父类定义的通用成员

                2）向下转型：已经转型成父类的子类对象在转成子类

 

instanceof

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

作用：运行期类型识别

*对真实类型及父类型判断，都得到true

  eg:Shape s=new Line();

      s  instanceof  Line    ===>true

       s instanceof  Shape   ===>true

 

 

抽象类

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

*作用：*）为子类提供通用代码

              *）为子类提供通用方法的定义

               *）抽象类相当于半成品类，不能创建对象，主要由子类来实现抽象类中未完成的方法，包含抽象方法的类一定是抽象类，抽象类中不一定包含抽象方法

 

 

final

------------------------------------------------------·

*修饰变量 、方法  、类

*final变量

   *）变量的值不可变，称为常量

   *）基本类型             值 本身不可变

    *）引用类型  引用的内存地址不可变

             eg：  final  int a=10;

                         a=100;  错    a的值不可变

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

                   final  Point a=new Point(2,3)

                       a.x=20;

                       a=new Point(5,7)

                       a=nul;

    *)final方法   1)方法不能再子类中重写

                          2）不能被继承  eg System.String

 

 

Static

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

*静态

*静态成员属于类，不属于实例

*静态成员可以称为：类变量  类方法

*非静态成员可以称为：实例变量   实例方法

*一般用类名调用静态成员：eg:   A.age

                                                   Integer.MAX_VALUE

                                                   Math.radom

*静态方法中不能调用非静态成员

*什么时候使用静态

           *）使用原则：*）能不用就不用

                                 *）静态是非面向对象的语法

          *）使用场景：*）共享的数据   *）共享的工具方法

                                eg:Math.random()

 

静态初始化块

     class A{

             static{

                     在类加载时只执行一次

             }

     }

 

常量

    * static final

           static final int MAX_VALUE = 100;

对象创建过程：

     class A{

                int V1 = 1;

                static int V2 = 2;

                static{

                       ......

                        }

 

                public A(){

                     ..............

                 }

     }

 

class B extends A{

          int V3 = 3;

         static int V4 = 4;

         static{

               ......

        }

       public B(){

       ......

      }

}

 

new B();

 

*)第一次用到A B两个类

      1）加载父类，为它的静态变量分配内存；

      2）加载子类，为它的静态变量分配内存；

      3）执行父类的静态变量的赋值运算，并执行静态初始化块

      4）执行子类静态变量的赋值运算符，并执行静态初始化块

*）每次创建对象时

      5）为父类对象分配内存，为它的非静态变量分配内存

     6）为子类对象分配内存，为它的非静态变量分配内存

     7）执行父类非静态变量的赋值运算

     8）执行父类的构造方法

     9）执行子类的非静态变量的赋值运算

    10）执行子类的构造方法  

 

访问控制符

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

     *控制一个类或类中的成员的访问范围

                           类      包      子类    任意 

   public            OK     OK     OK      OK

   protected      OK     OK     OK

   [default]          OK     OK

   private          OK

 

   选择的原则：

        *）尽量选择小的范围

       *）public 是与其他开发者的契约，最好保持稳定的对外输出值或返回值。

 

接口

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

  *作用：  结构设计工具，用来解耦合

  *接口是极端的抽象类

  *用interface 代替了class，用inplements代替extends

  *接口中只能定义： *）公开的抽象方法   *）公开的常量   *）公开的内部类、内部接口

  *一个类可以实现多个父接口 

      class A inplements B,C,D{  ......}

      class A extents B implements C,D{......}

      

*接口之间继承

     interface A  extends B,C,D{......}

 

内部类

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

*定义在类的内部、方法内部或局部代码块内的类

*可分为：非静态内部类、静态内部类、局部内部类和匿名内部类

 

非静态内部类：

   *）非静态内部实例依赖外部实例存在

   *）非静态内部类中不能定义静态成员

     

    class A{

         class Inner{

           ...... 

       }

    ........

   }

 

A a = new A();

Inner inner = a.(new Inner());

 

静态内部类

     class A{

           static class Inner{

              ........... 

          }

     }

A.Inner innner = new  A.Inner();

 

局部内部类

   class A{

       Weapon  fun {

               class Inner implements Weapon{

                    public  void kill(){

                       .....

                     }

             }

                Inner inner = new Inner();

               return inner;

       }

   }

   A a = new A();

 Weapon w = a.fun();

 w.kill();

 

匿名内部类

   Weapon w = new Weapon(){

      .......

    }