Java学习之路（4）----Java面向对象

前言

开始学习Java 面向对象编程

第一章 继承

1.1 概念

（1）类的继承格式

class 父类 {
}
 
class 子类 extends 父类 {
}

（2）继承的特性

• 需要注意的是 Java 不支持多继承，但支持多重继承。
• 子类拥有父类非 private 的属性、方法。
• 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
• 子类可以用自己的方式实现父类的方法。
• Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 A 类继承 B 类，B 类继承 C 类，所以按照关系就是 C 类是 B 类的父类，B 类是 A 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。
• 提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

注意：（该注意引用他人的博客，特标注出来）

• java继承中对构造函数是不继承的，只是调用（隐式或显式）。
• 在创建子类的对象时，Java虚拟机首先执行父类的构造方法，然后再执行子类的构造方法。在多级继承的情况下，将从继承树的最上层的父类开始，依次执行各个类的构造方法，这可以保证子类对象从所有直接或间接父类中继承的实例变量都被正确地初始化。

原文链接

1.2 继承关键字

1.2.1 extends关键字

在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类。

1.2.2 implements关键字

使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。

public class C implements A,B {
}

1.2.3 super与this关键字

• super ：访问父类
• this：访问自己

class Animal{
 
 void eat(){
  System.out.println("animal eat");
 }
}

class Dog extends Animal{
 
 void eat(){//成员方法重写
  System.out.println("dog eat");
 }
 void eatTest(){
  System.out.println("--------");
  eat();//调用子类的，因为重写
  this.eat();
  super.eat();
 }
 
 void eat2(){
  System.out.println("--------");
  
 }
}

public class JiCheng{
 
 
 public static void main(String[] args){
  
  Animal a = new Animal();
  a.eat();
  Dog d = new Dog();
  d.eat();
  d.eatTest();
  Animal a2 = new Dog();
  a2.eat();//编译可以过，并且因为重写，虚拟方法
  //a2.eatTest();//出错，因为a2是Animal类型，编译不能过
 }
}

animal eat
dog eat
--------
dog eat
animal eat
dog eat

1.2.4 构造器

class SuperTest{
 
 SuperTest(){
  System.out.println("SuperTest()");
  
 }
 SuperTest(int n){
  System.out.println("SuperTest(int n)"); 
  System.out.println(n);
 }
}
class STest1 extends SuperTest{
 
 STest1(){//调用SuperTest()
  System.out.println("STest1()");
 }
 
 STest1(int n){
  super(10);//SuperTest(int n)
  System.out.println("STest1(int n):"+n);
  
 }
}
class STest2 extends SuperTest{
 
 STest2(){
  super(20);//调用SuperTest(int n)
  System.out.println("STest2()");
 }
 
 STest2(int n){
  //调用SuperTest()
  System.out.println("STest2(int n):"+n);
 }
}
public class JiCheng{
 
 public static void main(String[] args){
  
  SuperTest t1 = new SuperTest();
  SuperTest t2 = new SuperTest(30);
  
  STest1 t3 = new STest1();
  STest1 t4 = new STest1(80);
  
  STest2 t5 = new STest2();
  STest2 t6 = new STest2(90);
 }
}

SuperTest()
SuperTest(int n)
30
SuperTest()
STest1()
SuperTest(int n)
10
STest1(int n):80
SuperTest(int n)
20
STest2()
SuperTest()
STest2(int n):90

第二章 重写

方法的重写规则

参数列表必须完全与被重写方法的相同。
返回类型与被重写方法的返回类型可以不相同，但是必须是父类返回值的派生类（java5 及更早版本返回类型要一样，java7 及更高版本可以不同）。
访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为 public，那么在子类中重写该方法就不能声明为 protected。
父类的成员方法只能被它的子类重写。
声明为 **final 的方法不能被重写**。
声明为 **static 的方法不能被重写**，但是*能够被再次声明*。

子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为 private 和 final 的方法。
子类和父类不在同一个包中，那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法。
重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
**构造方法不能被重写**。
如果不能继承一个方法，则不能重写这个方法。

第三章 多态

多态的优点

1. 消除类型之间的耦合关系
2. 可替换性
3. 可扩充性
4. 接口性
5. 灵活性
6. 简化性

多态存在的三个必要条件

• 继承
• 重写
• 父类引用指向子类对象

Parent p = new Child();

多态的实现方法

（1）重写
（2）接口
（3）抽象类和抽象方法

虚函数

使用父类引用去实=实例化子类对象，在调用重写方法，编译时，编译器使用父类被重写的方法验证该语句，执行时，JVM调用子类的重写方法。
这一过程：虚拟方法的调用，该方法：虚拟方法(重写的方法）。

第四章 抽象类

（1）定义抽象类

使用abstract class 来定义抽象类

public abstract class 类名{
}

（2）抽象方法

public abstract 数据类型 函数名（）；

（3）继承抽象类
可按照普通继承时的声明语句结构进行声明

抽象类名 引用变量名 = new 子类类名（）；

（4）类为抽象函数

public abstract class ATest2 extends ATest{
 
 ATest2(){
  super(30);
  System.out.println("ATest2()");
 }
 ATest2(int n){
  this.n = n;
  System.out.println("ATest2(int n):"+this.n);
 }
 
 public abstract void AT1();
}

• 抽象函数不能实例化对象，必须被继承才可以实例，只有抽象类的非抽象子类可以创建对象。

• 抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口

• 抽象方法只包含一个方法名，而没有方法体

• 抽象方法要被重写才可以被调用

• 如果子类没有对抽象方法重写，该子类必须被定义为抽象类，即抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。

• 抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

• 构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法

第五章 this关键字和空值

5.1 this关键字

（1）概念

结果：得到3个一样的值。

• 构造不同对象，this所指的不同，因为对象不同
• 构造不同对象调用同一个函数时，成员方法中的成员变量会默认加上this.，因为this不同，所以调用结果也不同

（2）当成员变量名与形参相同时

成员变量的有效范围从定义开始到类体结束
形参变量的有效范围从声明开始到方法体结束

根据就近原则，相当于两个形参自己给自己赋值，成员变量还是没改变，因此改为：

this.成员变量名 = 形参名；//表示将形参赋值给成员变量

（3）调用其他构造函数

本例会变成递归调用
值得注意的是：
　　1：在构造调用另一个构造函数，调用动作必须置于最起始的位置。
　　2：不能在构造函数以外的任何函数内调用构造函数。
　　3：在一个构造函数内只能调用一个构造函数。

（4）总结：

5.2 空值