java基础复习之面向对象语法基础

面向对象
======================================
  * 将复杂问题分解，
    分解成一个一个的独立的小问题，
    通过解决每个小问题，
    最终解决复杂问题
  
  * 封装、继承、多态


  类
  对象（实例）
  引用
  构造方法
  this
  重载
  
  继承
  super
  重写
  
  多态
  向上向下转型
  instanceof
  
  抽象类
  
  访问控制符
  final
  static
  
  接口
  
  内部类

类

==================================
  * 类比成“图纸”
  
  * 对事物、逻辑、算法、概念的抽象
  
  * java 类型系统中，是一种新的类型

对象（实例）

==================================
  * 类比成“从图纸生产出的产品”
  * 从类创建的实例
  * 每个对象，都是独立的，
      占用独立的内存空间
      在它的内存控件中，保存独立的属性值
      可以独立的执行运算

引用

==================================
  * 类比成“遥控器”


  * 引用类型变量
    保存一个实例的内存地址
    
  * 特殊值： null
      
      空，不保存任何实例的内存地址

构造方法

=======================================
  * 新建实例时执行的一个特殊方法
        
        new Soldier();
        new Soldier(9527);
        new Soldier(9527, 200);


  * 可以添加任意参数的构造方法
  
  * java 的任何类，都必须有构造方法
  * 如果不编写构造方法，
    编译器编译时，会添加默认构造方法
        
        class A {
            //如果不写，编译时添加默认构造方法：
            public A() {
            }
        }


  * 构造方法的作用：
        
        *) 不知道，
           在构造方法中，可以编写任意代码


        *) 常见用法：
           对成员变量初始化（即赋值）

this

=======================================
  * 实例中的特殊引用，
    通过 this 可以找到当前实例的内存地址
    
  * 构造方法之间调用
        
      this(参数)
      
      *) 减少重复代码
      *) 必须是构造方法中的首行代码
      

方法重载 Overload

=======================================
  * 同名不同参

继承

=======================================
  * 作用： 代码重用、代码复用
  
  * A 继承 B
      
      *) A 是 B 的子类
      *) B 是 A 的父类


  * 单继承
      
      *) 子类只能有一个父类
      *) 父类可以有多个子类
  
  * 新建子类实例时：
  ---------------------------------
      1) 新建父类实例，执行父类构造方法
      2) 新建子类实例，执行子类构造方法
      
      *) 两个实例捆绑在一起作为一个子类实例
      *) 访问成员时，现在子类中查找，再到父类中查找
  
  * 新建子类实例时，构造方法如何执行
  ---------------------------------
      *) 默认执行父类无参构造方法
      
            super();
      
      *) 可在子类构造方法中，
         手动调用父类有参构造方法
         
            super(参数);
  
  * 方法重写 Override
  ---------------------------------
      *) 从父类继承的方法对子类不适用，
         可以在子类中重新编写这个方法
      
      *) 签名(方法名、参数列表)必须一致
      *) 返回类型不能变大或改为其他类型
      *) 抛出的异常不能更多
      
      *) 可以复用父类中同一个方法的代码
            
            super.xxxx();
  

  * super

  ---------------------------------
      1. 子类构造方法调用父类构造方法


            super()       隐含调用
            super(参数)   手动调用
            
            *) 必须是构造方法的首行代码
      
      2. 重写方法时，调用父类同一个方法
            
            super.xxxx();

多态

=========================================
  * 作用： 一致的类型
  
  * 类型转换
        
        *) 向上转型
           子类实例，可转为父类型
           
              *) 向上转型后，只能调用父类定义的通用成员
           
        *) 向下转型
           转为父类型的子类实例，
           再转回成子类型


  * instanceof
    运行期类型识别
    
        *) 对真实类型及其父类型判断
           都返回 true
        
        Shape s = new Line();
        
        s instanceof Line     true
        s instanceof Shape    true

抽象类

=======================================
  * 作用：
        1) 为子类提供通用代码
        2) 为子类提供通用方法定义
  
  * 半成品类
  
  * 有的方法有代码
    有的方法没有代码，没有实现
  
  * 有抽象方法的类，必须是抽象类
  * 抽象类中，不一定有抽象方法
  
  * 抽象类不能创建实例

访问控制符

============================================
  * 对类或成员进行访问范围限制
  
                        本类    本包    子类    任意
  public            O            O        O       O
  protected      O            O        O
  [default]         O            O
  private           O


  * 访问控制符使用原则：
        
        尽量小范围访问
        
        *) 公开的成员，是与其他开发者的一个契约
        *) 公开的成员，会尽量保持稳定不变

final

===========================================
  * 可以修饰变量、方法、类
  
  * 变量
  -----------------------------------
    * 变量的值不可变，称为“常量”
          
          final int a = 10;
          a = 11;//错，a 一旦赋值，不能改变
          
          
          final Point a = new Point(2,3);
          a.x = 20;//对，引用的实例的成员可变
          a = new Point(1,2);//错，引用变量a中保存的内存地址不可变


    * 方法
          
          不能被子类重写
    
    * 类
          
          不能被继承

static

=============================================
  * 静态
  * 静态的成员，属于类，而不属于实例
  
  * 应该使用类名调用静态成员
        
        Integer.MAX_VALUE
        Math.pow(a,b)
  
  * 静态代码块中，不能访问非静态成员
  
  * 静态初始化块
        
        class A {
            static {
                //第一次用到 A 类
                //加载 A 类时执行
                //只执行一次
            }
        }
    
  * 什么时候使用静态
  ----------------------------------------
    * 原则： 能不用就不用
             静态是“非面向对象”语法
    
    * 使用场景：
    ------------------------
        *) 共享的数据
        
              Integer.MAX_VALUE
              Math.PI
        
        *) 工具方法
              
              Integer.parseInt()
              Math.pow()
              Math.sqrt()

常量

=====================================
  * java 中定义常量通常使用 static final
        
        static final byte MAX_VALUE=127;
        
        *) final 不可变
        *) static 内存中只存在一个地址，节省内存
  
  * 命名习惯：
        全大写
        单词之间用下划线
  

接口

=====================================
  * 作用：
        结构设计工具
        用来解耦合
    
  * 极端的抽象类
  
  * 用 interface 代替 class 
  * 用 implements 代替 extends 
  
  * 接口中只能定义：
        *) 公共的抽象方法
        *) 公共的常量
        *) 公共的内部类、内部接口
    
  * 接口可以多实现
        
        class A extends Xxx impelents B,C,D {
        }


  * 接口之间继承
        
        interface A extends B,C,D {
        }

内部类

=====================================
  * 定义在类内，或方法内，或局部代码块内的类
  
  * 非静态内部类
    非静态内部类的实例，依赖于外部类实例存在
        
        class A {
            class Inner {
            }
        }
        
        A a = new A();
        A.Inner i = a.new Inner();
        
        A.Inner i = new A().new Inner();
  
  * 静态内部类
        class A {
            static class Inner {
            }
        }
        
        A.Inner i = new A.Inner();


  * 局部内部类
        
        class A {
            Weapon a() {
                class Inner implents Weapon {
                }
                
                Inner i = new Inner();
                return i;
            }
        }
        
        
        A a = new A();
        Weapon w = a.a();




  * 匿名内部类  
  
        Weapon w = new Weapon() {
            ...
        };
        
  * 局部内部类中使用外面的局部变量，必须加 final