面向对象

*是一种认为抽象的编程模型

*复杂问题分解成一个个独立的小问题，通过单独解决每个小问题，来解决复杂问题

类

*理解成“图纸”

*对事物、算法、逻辑、概念的抽象

*封装（将相关的数据、代码封装成一个类组件）

对象(实例)

*理解成从“图纸”创建的“产品”

*每个对象占用独立的内存空间，保存自己的属性数据

*每个对象可以独立控制让他执行指定方法的代码

引用

*理解成“遥控器”

*引用变量保存一个对象的内存地址

通过引用，可以找到这个对象的存储空间，并调用它的成员

*引用类型的特殊值：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是父类型