面向对象
*是一种认为抽象的编程模型
*复杂问题分解成一个个独立的小问题，通过单独解决每个小问题，来解决复杂问题

类
*理解成“图纸”
*对事物、算法、逻辑、概念的抽象
*封装（将相关的数据、代码封装成一个类组件）

对象(实例)
*理解成从“图纸”创建的“产品”
*每个对象占用独立的内存空间，保存自己的属性数据
*每个对象可以独立控制让他执行指定方法的代码

引用
*理解成“遥控器”
*引用变量保存一个对象的内存地址
通过引用，可以找到这个对象的存储空间，并调用它的成员
*引用类型的特殊值：null
null 空；
表示不引用热河对象的内存地址

构造方法
* 新建实例时，执行的特殊方法
new Soldier()
new FlashLight()
new Car()
new Dog()
new Point()
* 一个类，必须有构造方法
* 如果不定义构造方法，
编译器编译代码时，
会添加默认构造方法
class A {
public A() {
}
}
* 构造方法重载
class A {
public A() {
}
public A(int i) {
}
public A(int i, String s) {
}
}
* 构造方法之间调用
this(…)
减少代码重复

This
* 两种用法
* 引用当前对象，保存当前对象的内存地址
this.xxx
f(this)
A a = this;
* 构造方法间调用
this(…)
*) 必须是首行代码

java 的参数传递 - 传值

• 基本类型变量中的值，是值本身
  main() {
  int a = 10;
  f(a);//取出a的值，传递到f()方法的参数变量a
  print(a);//打印 10
  }
  …
  void f(int a) {
  a = 100;
  }

• 引用类型变量中的值，是内存地址
  main() {
  Point a = new Point(3,4);
  f(a);//a的值是内存地址，将内存地址传到f()方法
  print(a.x);
  print(a.y);
  }
  f(Point a) {//参数a引用上面同一个对象的地址
  a.x = 30;
  a.y = 40;
  }

  重载 Overload
  *同名不同参

  继承

• 作用： 代码重用、代码复用

• 单继承：
  *)子类，只能有一个父类
  *)父类，可以有多个子类
  *)子类，可以隔层继承多个父类

• 重写 Override
  从父类继承的方法，
  不满足子类需要，
  可以在子类中重新编写这个方法
  *)重写一个方法时，
  可以用 super.xxx()
  调用父类同一个方法的代码

• 创建子类对象
  1)先创建父类对象,执行父类构造方法
  2)再创建子类对象,执行子类构造方法

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

  *)调用成员时，
  先找子类，再找父类

• 创建子类对象时，先执行父类构造方法

  *)默认执行父类无参构造方法
  super()

  *)手动调用父类有参构造
  super(参数)

  Super

  • 两种用法

    • 重写时，调用父类同一个方法
      public String toString() {
      …
      super.toString()
      …
      }

  • 手动调用父类构造方法
    super(参数)
    *) 必须是首行代码

  多态
  *作用：一致的类型
  *类型转换
  *）向上转型
  子类对象，转换成父类类型

  *）向下转型
  已经转为父类型的子类对象，再转回子类型

  *instanceof
  判断一个对象的类型
  对真实类型，及其父类型判断，都得到true
  Share s = new Line()
  s instanceof Line true
  s instanceof Share true

  抽象类
  *作用：
  *）为子类提供通用代码
  *）为子类提供通用方法的定义

  *抽象类是半成品类，没有完成的类
  *抽象类不能创建实例，只能创建他子类的实例

  *包含抽象方法的类，必须是抽象类
  抽象类中，不一定包含抽象方法

  Final
  *修饰变量，方法和类
  *变量：意味着变量的值不可变，成为“常亮”
  *）基本类型的值，是值本身不可变
  *）引用类型的值，是引用地址不可变
  Final int a = 10; A=11//错

  Final point a = new point (3.4);
  A.x = 30;对
  A = new point(1,5);错
  A =null;错

  *方法：方法不能被子类重写

  *类：不能被继承

  Static （静态）
  *静态成员属于类，而不属于实例
  Class soldier{
  Int id;
  }
  *调用静态成员，应该使用类名调用
  Soldier s1 = new soldier();
  Soldier s2 = new soldier();
  //下面代码容易误解
  S1.count = 1;
  S2.count = 2;
  Print(s1.count)

  Soldier count = 3；
  Print(soldier.count);

  *什么时候使用静态
  *）使用原则：能不用就不用。
  静态是“非面向对象”的语法
  *）使用场景：
  *）实例间共享的数据
  *）工具方法
  Math.sqrt()
  Integer.parrseint()

  *静态方法中，不能调用非静态成员
  Class a{
  Public static void main(String[] arges){
  //f();//错不能调用非静态成员
  A a=new A();
  A.f();

     g();
  }
  
     Static void g(){
    }       
  
  Void f(){
        }
  

  }

*静态初始化快
Class A{
Static{

}
}
*)第一次用到A类，加载A类是，只执行一次

常量
*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(){
…..
}
}

B b = new B();
*第一次用到A类和B类
1.加载父类，为父类静态成员变量分配内存
2.加载子类，为子类静态成员变量分配内存
3.执行父类静态变量赋值运算，并执行静态初始化块
4.执行子类静态变量赋值运算，并执行静态初始化块

*再次用到A类和B类
5.创建父类对象，为父类非静态变量分配内存
6.创建子类对象，为子类非静态变量分配内存
7.执行父类非静态变量赋值运算
8.执行父类构造方法
9.执行子类非静态变量赋值运算
10.执行子类构造方法

访问控制符
*控制类和类中的成员的访问范围
类 包 子类 任意
Public 0 0 0 0
Protected 0 0 0
[default] 0 0
Private 0

*)如何选择访问控制符
原则：尽量使用小范围
Public 是与其他开发者的契约，约定公开的东西会保持稳定不变
Private 隐藏。便于代码的维护和修改，不会对其他程序组件造成影响

接口
*作用：结构设计工具，用来解耦合
*是极端的抽象类
*用interface代替class关键字
*用implement代替 extends关键字
*接口中只能定义
*）公开的常量
*）公开的抽象方法
*）公开的内部类、内部接口

*一个类可以同时实现多个接口
Class A implements B,C,D{
}
Class extends B implement C,D,E{
}
*接口之间继承
一个接口，可以集成多个其他的父接口
Interface A extends B,C,D{
}

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

*非静态内部类
*)非静态内部类，依赖于外部类实例存在
*) 非静态内部类中，不能定义静态成员
Class A{
Class Inner{
}
}
A a = new A();
A.Inner i = a.new Inner();

*静态内部类
Class A{
Static class Inner{
}
}
A.Inner i = new A.Inner();

*局部内部类
*）拒不定义的类型，只能在局部代码块内使用
Class A{
Weapon f(){
Class Inner implements Weapon{
}
Inner i = new Inner();
Return i;
}
}

A a = new A();
Weapon w = a.f（）；
W.kill();

*匿名内部类
Weapon w = new Weapon(){…..};
*)大括号是匿名类
*)new新建匿名类实例
*)Weapon是父类型