JAVA 第三章 —— 继承

1. 继承

1.1继承的概念

继承是 java 面向对象编程技术的一块基石，因为它允许创建分等级层次的类。

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

1.2类的继承格式

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

公共父类：

public class Animal { 
    private String name;  
    private int id; 
    public Animal(String myName, int myid) { 
        name = myName; 
        id = myid;
    } 
    public void eat(){ 
        System.out.println(name+"正在吃"); 
    }
    public void sleep(){
        System.out.println(name+"正在睡");
    }
    public void introduction() { 
        System.out.println("大家好！我是"         + id + "号" + name + "."); 
    } 
}

这个Animal类就可以作为一个父类，然后企鹅类和老鼠类继承这个类之后，就具有父类当中的属性和方法，子类就不会存在重复的代码，维护性也提高，代码也更加简洁，提高代码的复用性（复用性主要是可以多次使用，不用再多次写同样的代码） 继承之后的代码：

企鹅类:

public class Penguin extends Animal { 
    public Penguin(String myName, int myid) { 
        super(myName, myid);   //super 调用父类构造方法
    } 
}

老鼠类:

public class Mouse extends Animal { 
    public Mouse(String myName, int myid) { 
        super(myName, myid); //super 调用父类构造方法，并向其传参数
    } 
}

1.3继承类型

注意：需要注意的是 Java 不支持多继承，但支持多重继承。

image.png

1.4继承的特性

• 子类拥有父类非 private 的属性、方法。

• 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。

• 子类可以用自己的方式实现父类的方法。

• Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 A 类继承 B 类，B 类继承 C 类，所以按照关系就是 C 类是 B 类的父类，B 类是 A 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。

• 提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

1.5 继承关键字

继承可以使用 extends 和 implements 这两个关键字来实现继承，而且所有的类都是继承于 java.lang.Object，当一个类没有继承的两个关键字，则默认继承object（这个类在 java.lang 包中，所以不需要 import）祖先类。

extends关键字

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

public class Animal { 
    private String name;   
    private int id; 
    public Animal(String myName, String myid) { 
        //初始化属性值
    } 
    public void eat() {  //吃东西方法的具体实现  } 
    public void sleep() { //睡觉方法的具体实现  } 
} 
 
public class Penguin  extends  Animal{ 
}

implements关键字

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

public interface A {
    public void eat();
    public void sleep();
}
 
public interface B {
    public void show();
}
 
public class C implements A,B {
}

super 与 this 关键字

super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。

this关键字：指向自己的引用。

class Animal {
  void eat() {
    System.out.println("animal : eat");
  }
}
class Dog extends Animal {
  void eat() {
    System.out.println("dog : eat");
  }
  void eatTest() {
    this.eat();   // this 调用自己的方法
    super.eat();  // super 调用父类方法
  }
}

final关键字

final 关键字声明类可以把类定义为不能继承的，即最终类；或者用于修饰方法，该方法不能被子类重写：
声明类：

final class 类名 {//类体}

声明方法：

修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}

注:实例变量也可以被定义为 final，被定义为 final 的变量不能被修改。被声明为 final 类的方法自动地声明为 final，但是实例变量并不是 final

2. Object：所有类的超类

2.1 概念

Obje类是所有Java类的祖先。每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。
在不明确给出超类的情况下，Java会自动把Object作为要定义类的超类。
可以使用类型为Object的变量指向任意类型的对象。
Object类是Java中唯一没有父类的类
Object类有一个默认构造方法pubilc Object()，在构造子类实例时，都会先调用这个默认构造方法。

2.2 Object中几个重要的方法：

• equals() (判断两个对象是否相等，用于比较两个对象的内存地址)

1）基本数据类型，也称原始数据类型。byte,short,char,int,long,float,double,boolean 他们之间的比较，用双等号（==）,比较的是他们的值。

2）复合数据类型(类) 当他们用（==）进行比较的时候，比较的是他们在内存中的存放地址，所以，除非是同一个new出来的对象，他们的比较后的结果为true，否则比较后结果为false。

• hashCode()( 返回该对象的哈希码值)

hashCode 的常规协定是（重写equals()时，必须重写hashcode()并保证此协定）：

    如果调用equals方法得到的结果为true，则两个对象的hashcode值必定相等
    如果equals方法得到的结果为false，则两个对象的hashcode值不一定不同
    如果两个对象的hashcode值不等，则equals方法得到的结果必定为false
    如果两个对象的hashcode值相等，则equals方法得到的结果未知

• toString()(返回该对象的字符串表示)

  Object类中的toString()方法会打印出类名和对象的内存位置。几乎每个类都会覆盖该方法，以便打印对该对象当前状态的表示。大多数（非全部）toString()方法都遵循如下格式：类名[字段名＝值，字段名＝值...]，当然，子类应该定义自己的toString()方法。该方法是非常重要的调试工具，很多标准类库中的类都定义了toString()方法，以便程序员获得有用的调试信息

public static void main(String[] args) {
        Main m = new Main();
        System.out.println(m.toString());  //complete.Main@7852e922
        System.out.println(m);   //complete.Main@7852e922
    }

注意： java 是开源，源代码公开，，，

查看源代码方式：

方式一：按住 Ctrl 键，单机你需要看的源代码。
方式二：把光标移动到你需要查看代码处，按下 F3

为什么要查看源代码？

1.查看源代码可以了解别人是如何写出这个技术的，让我们了解的更加的深入。
2.吸收大牛思想。

toString() 方法有何作用？
重写 toString() 之后，我们直接输出一个对象的时候，就会输出符合我们所需求的格式数据

class person {
    String name;
    int age;

    public person(String name, int age) {
        this.name = name;
        this.age = age;
    }
//重写 toString() 方法
    public String toString() {             
        return "姓名：" + this.name + " 年龄：" + this.age;
    }
}
public class Main {

    public static void main(String[] args) {
        person p = new person("haha", 18);
        System.out.println(p);
    }
}

结果：

image.png

3. 泛型

3.1 泛型定义：

Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。
泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

例如：

需求：写一个排序方法，能够对整型数组、字符串数组甚至其他任何类型的数组进行排序，该如何实现？

答案：是可以使用 Java 泛型。

3.2 泛型方法

你可以写一个泛型方法，该方法在调用时可以接收不同类型的参数。根据传递给泛型方法的参数类型，编译器适当地处理每一个方法调用。

下面是定义泛型方法的规则：

• 所有泛型方法声明都有一个类型参数声明部分（由尖括号分隔），该类型参数声明部分在方法返回类型之前（在下面例子中的<E>）。
• 每一个类型参数声明部分包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。
• 类型参数能被用来声明返回值类型，并且能作为泛型方法得到的实际参数类型的占位符。
• 泛型方法体的声明和其他方法一样。注意类型参数只能代表引用型类型，不能是原始类型（像int,double,char的等）。

public class Main {
    // 泛型方法 printArray
    public static <E> void printArray(E[] arry) {
        // 输出数组元素
        for (int i = 0; i < arry.length; i++) {
            System.out.printf("%s ", arry[i]);
        }
        System.out.println();
    }
    public static void main(String args[]) {
        // 创建不同类型数组： Integer, Double 和 Character
        Integer[] intArray = { 1, 2, 3, 4, 5 };
        Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
        Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };
        
        System.out.println("整型数组元素为:");
        printArray(intArray); // 传递一个整型数组

        System.out.println("\n双精度型数组元素为:");
        printArray(doubleArray); // 传递一个双精度型数组

        System.out.println("\n字符型数组元素为:");
        printArray(charArray); // 传递一个字符型数组
    }
}

结果：

image.png

3.3 泛型类

泛型类的声明和非泛型类的声明类似，除了在类名后面添加了类型参数声明部分。

和泛型方法一样，泛型类的类型参数声明部分也包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。因为他们接受一个或多个参数，这些类被称为参数化的类或参数化的类型。

举例：

public class Box<T> {
   
  private T t;
 
  public void add(T t) {
    this.t = t;
  }
 
  public T get() {
    return t;
  }
 
  public static void main(String[] args) {
    Box<Integer> integerBox = new Box<Integer>();
    Box<String> stringBox = new Box<String>();
 
    integerBox.add(new Integer(10));
    stringBox.add(new String("菜鸟教程"));
 
    System.out.printf("整型值为 :%d\n\n", integerBox.get());
    System.out.printf("字符串为 :%s\n", stringBox.get());
  }
}

结果：

image.png

4. 对象包装器与自动打包

4.1 对象包装器

所有基本类型都有一个与之对应的类，例如，Integer类对应基本类型int。通常，这些类称为包装器(wrapping)。

这些对象包装器拥有很鲜明的名字：Integer、Long、Float、Double、Short、Byte、Character、Void和Boolean（前面六个类派生于公共的超类Number）。对象包装器类是不可变的，一旦构造了包装器，就不允许更改包装器里面的值。同时，对象包装器还是final，因此不能定义他们的子类。

4.2 自动打包

定义一个整形数组列表，尖括号里面的参数类型不允许是基本类型，也就是说不允许写成ArrayList<int>。这里就用到了Integer对象包装器类。我们可以声明一个Integer对象的数组列表。

         ArrayList<Integer> list = new ArrayList<Integer>;

当调用：

         list.add(3);

将自动变换成：

         list.add(new Integer(3));

这种变换称之自动打包(autoboxing)。

相反的如果将Integer对象赋值给一个int值时，将会 自动第拆包 ,也就是说编译器将下列语句：

int n = list.get(i);

翻译成：

int n = list.get(i).intValue();

甚至在算术表达式中也能够自动的打包和拆包。例如，可以将自增操作符应用于一个包装器引用：

Integer n = 3;
n++;

编译器将自动第插入一条拆开对象包的指令，然后进行自增运算，最后再将结果打入对象包内。
很多情况下，容易有一种假象，即基本类型和他们的对象包装类是一样的，只是他们的相等性不同，==运算符也可以用于包装器对象，只不过检测的是对象是否指向同一个存储区域。

先看下面一段代码：

public class Main {
    public static void main(String[] args) {
         
        Integer i1 = 100;
        Integer i2 = 100;
        Integer i3 = 200;
        Integer i4 = 200;
         
        System.out.println(i1==i2);
        System.out.println(i3==i4);
    }
}

输出结果为：true，false。结果表明i1和i2指向的是同一个对象，而i3和i4指向的是不同的对象。下面这段代码是Integer的valueOf方法的具体实现：

public static Integer valueOf(int i) {
        if(i >= -128 && i <= IntegerCache.high)
            return IntegerCache.cache[i + 128];
        else
            return new Integer(i);
    }

自动打包要求规范要求boolean、byte、char<=127，介于-128~127之间的short和int被包装到固定的对象中，否则创建一个新的对象。如上面的i1和i2初始化为100，对他们的比较的结果一定是成立的。

所以在比较两个包装器对象的值是否相等时调用equals方法就能避免出现false的情况。

最后说明一下，打包和拆包是编译器认可的，而不是虚拟机。编译器在生成类的字节码时插入必要的方法调用。虚拟机只是执行这些字节码。

5.参数数量可变的方法

可变的参数类型，也称为不定参数类型。英文缩写是varargus，还原一下就是variable argument type。通过它的名字可以很直接地看出来，这个方法在接收参数的时候，个数是不定的。
Java开始支持可变参数的方法，比如printf方法就是一个可变参数的方法。

我们也可以自定义可变参数的方法，具体语法为：

  返回类型 函数名(参数类型...参数名字)

原理：就是将接收的参数组装成一个临时数组，然后再处理临时数组中的数据。

示例代码:

public class Main {

    public static double max(double... values) { // //定义可变参数 values
        double largest = Double.MIN_VALUE;  ////次数为 Double 能表示的最小值
        
        for (double v : values) { // 相当于把values数组里的每一个值取出赋于v,直到结束
            
           largest = v > largest ? v : largest; // 取大值
        }
        
        return largest;
    }

    public static void main(String[] args) {
        double m = max(1.2, 3.4, 56.7, 345.45, 2, 5);
        System.out.println(m);
    }

}

结果：

image.png

这段代码接受任意个double类型的参数，从中寻找其中的最大值并在控制台输出。

要点：

1. 在方法中定义可变参数后，我们可以像操作数组一样操作该参数；

2. 如果该方法除了可变参数还有其它的参数，可变参数必须放到最后；

3. 调用使用了可变参数的方法时：

   a. 可以不写参数，即传入空参；
   b. 可以直接在里边写入参数，参数间用逗号隔开；
   c. 可以传入一个数组；

6.枚举类

6.1 枚举的定义

这是在没有枚举类型时定义常量常见的方式

//使用普通方式定义日期常量
 
public class DayDemo {

    public static final int MONDAY =1;

    public static final int TUESDAY=2;

    public static final int WEDNESDAY=3;

    public static final int THURSDAY=4;

    public static final int FRIDAY=5;

    public static final int SATURDAY=6;

    public static final int SUNDAY=7;

}

上述的常量定义常量的方式称为int枚举模式，这样的定义方式并没有什么错，但它存在许多不足，如在类型安全和使用方便性上并没有多少好处，如果存在定义int值相同的变量，混淆的几率还是很大的，编译器也不会提出任何警告，因此这种方式在枚举出现后并不提倡，现在我们利用枚举类型来重新定义上述的常量，同时也感受一把枚举定义的方式，如下定义周一到周日的常量

//枚举类型，使用关键字enum
enum Day {
    MONDAY, TUESDAY, WEDNESDAY,
    THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

相当简洁，在定义枚举类型时我们使用的关键字是enum，与class关键字类似，只不过前者是定义枚举类型，后者是定义类类型。

枚举类型Day中分别定义了从周一到周日的值，这里要注意，值一般是大写的字母，多个值之间以逗号分隔。同时我们应该知道的是枚举类型可以像类(class)类型一样，定义为一个单独的文件，当然也可以定义在其他类内部，更重要的是枚举常量在类型安全性和便捷性都很有保证，如果出现类型问题编译器也会提示我们改进，但务必记住枚举表示的类型其取值是必须有限的，也就是说每个值都是可以枚举出来的，比如上述描述的一周共有七天。那么该如何使用呢？如下：

public class EnumDemo {

    public static void main(String[] args){
        //直接引用
        Day day =Day.MONDAY;
    }

}
//定义枚举类型
enum Day {
    MONDAY, TUESDAY, WEDNESDAY,
    THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

就像上述代码那样，直接引用枚举的值即可，这便是枚举类型的最简单模型。

6.2 枚举类的定义

枚举类和普通类有以下几个不同点：

1、枚举类不能指定继承的父类（因为继承了java.lang.Enum类），但是可以实现多个接口， 枚举类默认实现了Comparable接口和Serializable接口

2、枚举类的构造方法的访问权限只可为private

3、枚举类的实例必须显式列出。

6.3 枚举类的真正实现

举例：

public enum Season {
    SPRING("春天"), SUMMER("夏天"), AUTUMN("秋天"), WINTER("冬天");
    
    private final String chinese;
    
    private Season(String chinese) {
        this.chinese = chinese;
    }

    public String getChinese() {
        return chinese;
    }
}

其实上述代码相当于：

public final class Season extends Enum<Season> {
    public static final Season SPRING;
    public static final Season SUMMER;
    public static final Season AUTUMN;
    public static final Season WINTER;
    private static final Season[] ENUM$VALUES;
    static {
        SPRING = new Season("SPRING", 0, "春天");
        SUMMER = new Season("SUMMER", 1, "夏天");
        AUTUMN = new Season("AUTUMN", 2, "秋天");
        WINTER = new Season("WINTER", 3, "冬天");
        ENUM$VALUES = new Season[]{SPRING, SUMMER, AUTUMN, WINTER}
    }
    
    private final String chinese;
    
    private Season(String name, int ordinal, String chinese) {
        super(name, ordinal);
        this.chinese = chinese;
    }

    public String getChinese() {
        return chinese;
    }
    
    public static Season[] values() {
        Season[] arr = new Session[ENUM$VALUES.length];
        System.arraycopy(ENUM$VALUES, 0, arr, 0, arr.length);
        return arr;
    }
    
    public static Season valueOf(String name) {
        return Enum.valueOf(Season.class, name);
    }
}

在编译过程中，编译器会对枚举类进行以下处理：

1、增加一个静态初始化块和一个静态数组，静态初始化块负责构造枚举类的实例并将其保存到数组中。
2、修改当前枚举类的构造方法，向构造方法前面增加两个参数：name, ordinal。分别代表枚举类的名称和初始化顺序，并且使用super调用父类java.lang.Enum的构造方法。
3、添加两个静态方法：
public static Season[] values()
该方法返回一个数组，包含了该枚举类所有的实例（并不是返回枚举类自己保存实例的数组，而是通过对其复制，以确保实例不被篡改）。
public static Season valueOf(String name)
该方法通过当前枚举类的名称返回对应的实例。比如valueOf(“SPRING”)返回Season.SPRING）。

7.反射

7.1 反射的概念

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象.

反射就是把java类中的各种成分映射成一个个的Java对象

例如：一个类有：成员变量、方法、构造方法、包等等信息，利用反射技术可以对一个类进行解剖，把个个组成部分映射成一个个对象。
（其实：一个类中这些成员方法、构造方法、在加入类中都有一个类来描述）
如图是类的正常加载过程：反射的原理在与class对象。
熟悉一下加载的时候：Class对象的由来是将class文件读入内存，并为之创建一个Class对象。

image.png