Java基础2-面向对象

一、面向对象

1、面向对象主要针对面向过程。面向过程的基本单元是函数。

2、在 JAVA 中，一切都是对象，但我们用来操纵对象的却是引用。

3、对象包括变量( 属性) 和方法，变量表示对象的属性，方法用来描述对象的功能，处理过程。

4、对于对象的要求：高内聚、低耦合，这样容易拼装成为一个系统。

5、实现高内聚就是要最大限度降低提高复用性（复用性好是因为高内聚）。可复用性是 OOP 的基础。

6、面向对象是先有数据结构，然后再有算法。

二、类

1、从语法上来看，一个类是一个新的数据类型。

 类方法中的一类特殊方法：构造方法。构造方法是当用类生成对象时，系统在生成对象的过程中利用的方法。
注意：构造方法在生成对象的时候会被调用，但并不是构造方法生成了对象。构造方法没有返回值。构造方法的方法名与类名相同。如果用户没有为类编写构数方法，则系统会为该类生成一个无参的默认构造方法，否则，系统将不再为该类自动生成无参构造方法。

 this 表示当前对象，this() 表示本类构造方法。super 表示直接父类对象，super() 表示直接父类构造方法。 this()，super() 均可带参数。

三、继承

父类（SuperClass ）和 子类（SonClass ）。
父类的非私有化属性和方法（非构造方法）可以默认继承到子类。

class Son extends Father{
}

1、JAVA 中只支持单继承。JAVA 通过接口和内部类实现多继承。

2、父类的构造方法子类不能继承，子类只能在自已的构造方法中访问父类的构造方法。

方法覆盖(OVERRIDE) ：
当父类中的非私有方法跟子类的 方法名一样，参数一样，返回类型也一样时，称为子类方法对父类方法的覆盖。这时，子类方法的访问控制权限不能比父类方法的访问控制权限更严格，也不能抛出更多的异常 ，否则编译出错。这也是 JAVA 之所以有动态 多态 的原因。

修饰属性和方法的修饰符，以下范围依次由严到宽：
private ： 本类访问；
default ： 同包可见。
protected ：同包可见 + 子类可见
public：表示所有的地方均可见。

当构造一个对象的时候，系统先递归构造父类对象，再构造子类对象。

构造方法
super() 表示调用父类的构造方法。this() 用于调用本类的构造方法, 可以有参或无参,以此调用相应的构造函数。

 Super()和 和 this() 一样，如果出现，则必须放在构造函数的第一行。且两者不能同时出现在同一构造函数中。如果没有调用 super()和 和 this() 构造方法，那么系统会自动调用父类的无参构造方法，相当于 super() 。 因此在编写类时，如果定义了有参构造方法，则应同时定义一个无参构造方法，以便别人断承。

构造对象的顺序：
1、 加载类：① 静态变量 ；② 静态初始化块 ；③ static {}

2、判断构造函数中有没有this() 和super(), 如果有this(), 则调用本类相应的构造函数; 如果有super(),则调用父类相应的构造函数 ； 如果两个都没有，则调用父类无参构造函数；以此递归类推。

3、执行动态初始化块。{…….}

4、执行本类的构造方法。

提示：
1、为什么初始化一个子对象时必须先调用基类的构造方法？
因为子对象内部包含着一个父对象，所以，初始化子对象前必须先初始化这个在子对象内部 的父对象。父类在子类构造器可以访问它之前就已经完成了初始化。

2、执行类的所有特定的清理动作，其顺序跟生成对象的顺序相反，通常这就要求父类元素仍旧存活。

3. 组合和继承都允许在新的类中放置子对象，组合是显式地这样做，而继承是隐式地做。组合技术通常用于想在新类中使用现有类的功能而非它的接口的这种情形。当想使用现有类，并开发一个它的特殊版本时，则使用继承。

四、多态

 多态（迟后联编）：多态指的是运行时类型识别。当对象调用覆盖方法时，系统在编译过程中不对对象类型进行识别和方法绑定，而是在运行时才对该对象进行类型识别，并根据该对象的具体类型绑定执行相应类型中定义的覆盖方法。如果在子类里找不到相应的方法，才到父类里去打。多态之所以能体现出来，正是由于子类跟父类间发生的方法覆盖。

多态典型使用：
class Animal{
void eat(){};
}
class Dog extends Animal{
void eat(){};
}
class Pig extends Animal{
void eat(){};
}
Void go(Animal animal){
animal . eat();
}
Animal a=new Dog(); Pig p=new Pig();
go(a); go§;

关系运算符： instanceof
instance instanceof class
Animal dog=new Dog;
if (dog1 instanceof Dog)( 这个式子的结果是一个布尔表达式)
Dog dog2=(Dog) dog1;

 instanceof 用于判定前面的对象是否属于后面的类型。是则返回 true ，否则返回 false 。
 如果 dog is a Dog ，则可以对 dog 强制转换为 Dog 。

封装、继承、多态为面向对象的三大基石（特性）。

运行时的动态类型判定针对的是方法。运行程序访问的属性仍为编译时属性。

Overloading 针对的是编译时类型，不存在运行时的多态。

五、面向对象高级特性

static 修饰符
static : ①可修饰属性；②可修饰方法；③可修饰代码块。

 一般情况下，只能在类中定义静态方法和属性，而不能在一个方法中定义。静态属性用来作为一个 计数器。静态属性和方法都可以（最好）用类名直接调用，因为静态的东西属于类而不是属于对象，静态方法只能调用静态方法和属性。

提示：

1. main 方法为什么是 static 的？
   因为 main 方法是程序的入口，在起动程序时尚未建立对象，所以 main 方法必须是 static 的才能被调用，程序才能起动.
   当执行 java calssname 时，classname 自动调用静态 main 方法,相当于 classname.main()。

2. 静态方法不体现多态性,编译器只看编译时类型。

class A{
     static void eat(){System.out.println(“this is static A.eat()”);}
}
class B extends A{
     static void eat(){System.out.println(“this is static B.eat()”);}
}
class Test{
     A a=new B(); a.eat();//输出为：this is static A.eat()。
} }

①、当 static 修饰代码块时（注：此代码块要在此类的任何一个方法之外）：
static { } 静态初始化块

②、静态代码块在代码被装载进虚拟机时被执行。一般静态代码块被用来初始化静态成员。
{ } 动态初始化块。

③、创建对象时才执行。

3. 如何使一个类只能生成一个对象？单例模式

public class Test{
    public static void main(String[] args){
      A a=A.get(); A b=A.get(); System.out.print(a= =b);//true
    }
}

class A{
   static A a=new A();
   private A(){ }
   public static A get(){ return a;}
}

class B{
   private static B b;
   private B{}
   public static B get(){
       if(b= =null) b=new B(); return b;
   }
}

final 修饰符

final 可以修饰类、属性、方法。

1、当用 final 修饰的类不能被继承，即 final 类没有子类。用来确保声明的类不被修改。

2、当利用 final 修饰一个属性（变量）的时候，此属性成为常量。跟据命名规范，变量名全部大写。

3、当属性声明为 final 时，最好跟 static 联合在一起使用，以节省资源。

4、final 的属性在声明时一定要初始化，否则，就要在该类的构造函数中初始化。局部 final 变量可以随时赋值

5、当一个引用声明为 final 时，引用的值不能变，但引用所指向的对象的属性可变。

6、final 的方法不能被覆盖。用于在保持方法的一致性时。但可被重载。如果在父类中有 final 定义的方法， 那么在子类中继承同一个方法。

 如果一个方法前有修饰词 private 或 static，则系统会自动在前面加上 final。即 private 和 static  方法默认均为 final 方法。

 注：final 并不涉及继承，继承取决于类的修饰符是否为 private、default、protected 还是 public。 也就是说，是否继承取决于这个方法对于子类是否可见。

abstract 修饰符

abstract(抽象)可以修饰类、方法
如果将一个类设置为 abstract，此类不可生成对象，必须被继承使用。抽象类除了不能生成对象外，其它与变通类无异。抽像类继承一个类时，该类必须有无参构造方法，否则出错。

1、abstract 可以将子类的共性最大限度的抽取出来，放在父类中，以提高程序的简洁性。

2、abstract 虽然不能生成对象，但是可以声明 abstract 类的引用。

3、final 和 abstract 永远不会同时出现。

4、抽象类，一般无构造方法；

5、若抽象类有构造方法，一般声明为“protected”，供它的子类通过“super”调用。

 当 abstract 用于修饰方法时，此时该方法为抽象方法，不需要实现，实现留给子类覆盖，子类覆盖该方法之后方法才能够生效。

注意比较：
private void print(){}；此语句表示方法的空实现。
abstract void print()； 此语句表示抽象方法，无实现。

1、如果一个类中有一个抽象方法，那么这个类一定为一个抽象类。

2、反之，如果一个类为抽象类，那么其中可能有非抽象的方法。

3、如果一个类继承一个抽象类，则这个类必须实现(覆盖)该抽象类的所有抽象方法。

4、如果有抽象方法未被实现，则子类将继承父类的抽象方法，所以这个子类也一定是抽象类。

5、abstract 和 static，private，final 同时修饰一个类或方法。

interface 接口
1、接口与类属于同一层次，接口是一种特殊的抽象类。

2、接口不能生成对象，但可以声明引用；接口没有构造方法。

3、接口里定义的所有属性都一定是 public static final 的。所有方法都是 public abstract 的。

与类相似，一个文件只能有一个 public 接口，且与文件名相同。在一个文件中不可同时定义一个 public 接口和一个 public 类。一个类实现一个接口的格式：

interface IA{
}

 class IAImple implements IA{
};

一个接口可以 extends 另一个接口。一个类实现接口时，必须实现接口中及其父类的所有的方法。

接口中声明方法时可不写 public ，方法默认为 public abstract 的。但在子类中实现接口的过程中 public 不可省。

提示：

1. 为什么要有接口？为什么不直接用抽象类呢？
   用接口可以实现多继承；

① 一个类除继承另外一个类，还可以实现接口；
class IAImpl extends java.util.Arrylist implement IA {}
继承类Arrylist， 实现接口IA。

 这样可以实现变相的多继承。

② 一个类只能继承另外一个类，但是它可以实现多个接口，中间用“，”隔开。
Implements IA,IB
所谓实现一个接口，就是指实现接口中的方法。

③ 接口和接口之间可以定义继承关系，并且接口之间允许多继承。
例：interface IC extends IA,IB{};

 接口和多态都为 JAVA 技术的核心。

接口实际上是定义一个规范、标准。

① 通过接口可以实现不同层次、不同体系对象的共同属性；
通过接口实现 write once as anywhere.
以 JAVA 数据库连接为例子：JDBC 制定标准；数据厂商实现标准；用户使用标准。
接口通常用来屏蔽底层的差异。

② 接口也因为上述原因被用来保持架构的稳定性。

可以修饰类的修饰符有：
public , abstract , final , default

private , protected 不能修饰类。

String 类

String str1=”nihao”;
String str2=”nihao”;
str1 = = str2 //这种创建方法两个引用指向常量域的同一个”nihao”。

String str3=new String(“nihao”);
String str4=new String(“nihao”);
str3!=str4

1、字符串的解析:

public static void main(String [] args){
String tom=”12,152,54,1,22,96,696”;
int i=0;
String []s=null;

StringTokenizer st=new StringTokenizer(tom,”,”);
int n=st.countTokens();// 获取分隔后的元素个数.
while(st.hasMoreTokens()){// 还有更多元素？
s[i++]=st.nextToken();// 获取下一个元素.
}}

object 类
JAVA 中有一个特殊的类： Object 。它是 JAVA 体系中所有类的父类（直接父类或者间接父类）。

以下介绍的三种方法属于 Object：
(1) finalize() ：当一个对象被垃圾回收的时候调用的方法。

(2) toString()： 是利用字符串来表示对象。
当我们直接打印定义的对象的时候，隐含的是打印 toString() 的返回值。如果本类没有覆盖 toString()， 则系统自动调用其父类的 toString() 方法。可以通过子类定义 toString() 来覆盖父类的 toString()。 以取得我们想得到的表现形式，即当我们想利用一个自定义的方式描述对象的时候，我们应该覆盖toString() 。

(3) equals()：判断的是变量的值是否相等.equals() 方法判断的是对象的值是否相等。
用户如果想比较自定义的类的对象是否相等，就必须要在该类中覆盖 equals() 方法。

class Student{
     String name;
     int age;
     
public String toString(){
     return “name”+name+ “age:”+age;
}
public boolean equals(Object o){
     if(o==null) return false;
     if(o==this) return true;
     if(!(o instanceof Student)) return false;
     Student s=(Student)o;
     return name.equals(o.name)&&(age==age);
}
protected void finalize(){// 全靠系统决定，我们无法确定它什么时候执行。但一定是回收对象前做的事。
     System.out.print(“ 完了,完了”);
}
}

自反性：a.equals(a)=true
对称性：a.equals(b)=b.equals(a)
传递性：a.equals(b)=true
& b.equals©=true ?a.equals©=true

封装类：
JAVA 为每一个简单数据类型提供了一个封装类，使每个简单数据类型可以被 Object 来装载。

内部类
（注：所有使用内部类的地方都可以不用内部类，使用内部类可以使程序更加的简洁，便于命名规范和划分层次结构）。

1、内部类是指在一个外部类的内部再定义一个类。

2、内部类作为外部类的一个成员，并且依附于外部类而存在的。

3、内部类可为静态，可用 protected 和 private 修饰。 （而外部类不可以：外部类只能使用 public 和 default。

内部类的分类：
成员内部类、
局部内部类、
静态内部类、
匿名内部类（图形是要用到，必须掌握）。

1. 成员内部类
   1、作为外部类的一个成员存在，与外部类的属性、方法并列。不能和外部类同名，内部类和外部类的实例变量可以共存。成员内部类不能定义静态成员。

2、成员内部类可以访问外部类的所有属性和方法：外部类名 . this . 普通属性（方法） 。
外部类名 . 静态属性（方法）

3、外部类方法也可以访问内部类属性和方法：可以在外部类方法中生成一个内部类对象。
Inner in=new Inner(); in . 属性（方法）;

4、在别的类访问一个类中的成员内部类：Outer out=new Outer();// 先取得外部类的对象
Outer.Inner in=out.new Inner();

成员内部类的优点：
① 内部类作为外部类的成员，可以访问外部类的私有成员或属性。（即使将外部类声明为 private，但是 对于处于其内部的内部类还是可见的。）
对于一个名为 outer 为 的外部类和其内部定义的名为 inner 现 的内部类。编译完成后出现 outer.class 和 outer$inner.class 两类。

2. 局部内部类
   1、在方法中定义的内部类称为局部内部类。
   与局部变量类似，在局部内部类前不加修饰符 public 和 private ，其范围为定义它的代码块。

   注意：局部内部类不仅可以访问外部类实例变量，还可以访问外部类的局部变量（但此时要求外部类的
   局部变量必须为 final ）？？
   在类外不可直接生成局部内部类（保证局部内部类对外是不可见的）。

要想使用局部内部类时需要生成对象，对象调用方法，在方法中才能调用其局部内部类。

3. 静态内部类
   （注意：前三种内部类与变量类似，所以可以对照参考变量）

1、静态内部类定义在类中，任何方法外，用 static 定义。静态内部类可以定义静态成员。

2、静态内部类只能访问外部类的静态成员。 外部类名 . 静态属性（方法）

3、在别的类中生成（new）一个静态内部类不需要外部类对象：这是静态内部类和成员内部类的区别。静态内部类的对象可以直接生成：
Outer.Inner in=new Outer.Inner() ；
不能和外部类同名. 但可以定义静态和非静态成员。静态内部类不可用 private 来进行定义。例子：
对于两个类，拥有相同的方法：

People {
  run();
}
Machine{
  run();
}

此时有一个 robot 类：
class Robot extends People implement Machine.
此时 run() 不可直接实现。

注意：当类与接口（或者是接口与接口）发生方法命名冲突的时候，此时必须使用内部类来实现。
用接口不能完全地实现多继承，用接口配合内部类才能实现真正的多继承。

4. 匿名内部类（必须掌握）：
   匿名内部类是一种特殊的局部内部类，它是通过匿名类实现接口。
   IA 被定义为接口。
   IA I=new IA(){};

注：一个匿名内部类一定是在 new 的后面，用其隐含实现一个接口或实现一个类，没有类名，根据多态，我们使用其父类名。

因其为局部内部类，那么局部内部类的所有限制都对其生效。
匿名内部类是唯一一种无构造方法类。
匿名内部类在编译的时候由系统自动起名 Out$1.class 。