Java-继承与多态

继承与多态

类的继承

• 继承：从已有的类派生出新的类
• 使用 extends 来表示继承
• 已存在的类称为 父类
• 派生类得到的心累称为子类
• 子类是对父类的扩展，拥有更多的功能

Java只支持单一继承
一个子类只能有一个父类（儿子只有一个爹）
但是一个类可以被多个类继承（爹可以有好几个儿子）
可以通过简介继承实现多重继承的功能

class A {}
class B extends A {}
class C extends B {}

子类

• 子类继承父类中所有成员变量和成员方法
• 子类不继承父类的构造方法
• 在子类中添加新的属性和新的方法

  在创建类的对象时，首先执行父类的构造方法，然后执行子类相对应的构造方法

示例

Point 类

public class Point {
    double x;
    double y;
    public Point () {}
    public Point (double x, double y) {
        this.x = x;
        this.y = y;
    }
    public String toString () {
        return "Point [x=" + x + ", y=" + y + "]";
    }
}

ColorPoint 类

public class ColorPoint extends Point {
    public String color;
    public ColorPoint (double x, double y, String color) {
        this.x = x;    //①
        this.y = y;    //② 这两行可以换成：super(x, y);
        this.color = color;
    }
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
    public String toString() {
        return "ColorPoint [color=" + color + ", x=" + x + ", y=" + y + "]";
    }
}

• super 代表当前类的父类
• super(); 调用父类的默认构造方法
• super(参数列表); 调用父类中对应的构造方法
• super() 和 super(参数列表)必须出现在构造方法的第一行，而且是调用父类构造方法的唯一方法，当然你要是像例子中那样复制粘贴了父类的构造方法在子类中也ok。
• 如果子类构造方法中没有显式调用父类的构造方法，在产生子类的实例对象时，系统默认调用父类无参构造方法。
• 调用父类的非私有属性和方法：super.属性名; super.方法名(参数列表);

TestPoint 类

public class TestPoint {
    public static void main(String[] args) {
        Point point = new Point(3, 4);
        ColorPoint colorPoint = new ColorPoint(2, 3, "black");
        System.out.println(point.toString());
        System.out.println(colorPoint.toString());
    }
}

构造方法链

构造一个类的实例时，将会调用沿着继承链的所有父类的构造方法，这就是所谓的构造方法链。

属性隐藏

• 子类中的属性可以隐藏父类中的同名属性
• 在子类中访问父类的同名属性，必须使用super关键字

方法的重写（覆盖）

在编程的过程中，有时候我们需要继承一个父类来简化代码，但是经常会出现父类的方法不完全适用子类的情况，这时候就需要用到方法的重写（覆盖）

public class Point {
    public String toString() {
        return "Point [x=" + x + ", y=" + y +"]";
    }
}

public class ColorPoint extends Point {
    public String toString() {
        reuturn "ColorPoint [color=" + color + ", x=" + x + ", y=" + y + "]";
    }
}

当然如果在子类中对父类的方法进行了重写（覆盖）也是可以使用父类中该方法的，只需使用 super 关键字

Object 类

Object 类是所有类的父类

多态性

（搞不懂）

对象转换

Student b = o; ×
Student b = (Student)o; √

instanceof运算符

在尝试转换之前，确保对象是另一个对象的实例，可以采用运算符 instanceof 来实现

• 作用：
  ① 判断一个实例对象是否属于一个类；
  ② 判断一个实例是不是实现了某个接口类的对象。
• 返回值：false 或 true （布尔类型）

包（package）

作用

• 解决命名冲突，提供类的多层命名空间

没有 package 包的话，则默认无名包

import 语句

……

JDK中的常用包

• java.lang: Java语言的核心类
• java.awt: 构建图形用户界面
• java.applet: 包含applet运行所需的一些类
• java.net: 包含执行与网络操作相关的类
• java.io: 输入输出
• java.util: 实用工具类

访问控制

访问控制修饰符

• public
• protected
• default
• private

类的访问控制

• public，default

类成员的访问控制

• public
• protected
• default
• private

使用 protected 修饰的成员

• 可以被同一个包中的类访问
• 可以被子类访问

类成员访问控制小结

	private	default	protected	public
同一类	√	√	√	√
同一包中的类		√	√	√
子类			√	√
其他包中的类				√

final 关键字

• final 修饰的类不能被继承
• final 修饰的方法不能被子类覆盖
• final 修饰的变量为常量，只能赋值一次

ArrayList 类

• 可以存储不限定个数的对象

• ArrayList 是一种泛型类

• ArrayList 中的元素必须是一种对象，泛型类型不能是基本数据类型

  ArrayLIst<String> cities = new ArrayList<String> ();
  ArrayList<java.util.Date> dates = new ArrayList<java.util.Date> ();
  

  对列表有用的方法

  利用数组创建一个数组列表

  String[] array = {"red", "green", "blue"};
  ArrayList<String> List = new ArrayList<>(Array.asList(arrav));
  

利用列表创建一个数组

String[] array1 = new String[List.size()];
list.toArray(array1);

可以用 java.util.Collections 类中的 sort 对元素进行排序

Integer[] array = {"red", "green", "blue"};
ArrayList<Integer> List = new ArrayList<>(Array.asList(arrav));
java.util.Collections.sort(list);
System.out.println(list);

可以用 java.util.Collections 类中的 max 和 min 返回最大最小元素

……

可以用 java.util.Collections 类中的 shuffle 来随机打乱元素

什么是继承，继承的特点？

子类继承父类的特征和行为，使得子类具有父类的各种属性和方法。或子类从父类继承方法，使得子类具有父类相同的行为。

特点：在继承关系中，父类更通用、子类更具体。父类具有更一般的特征和行为，而子类除了具有父类的特征和行为，还具有一些自己特殊的特征和行为。

在继承关系中。父类和子类需要满足is-a的关系。子类是父类。

表示父类和子类的术语：父类和子类、超类和子类、基类和派生类，他们表示的是同一个意思。

为什么需要继承？什么时候应该继承？

使用继承可以有效实现代码复用，避免重复代码的出现。

当两个类具有相同的特征（属性）和行为（方法）时，可以将相同的部分抽取出来放到一个类中作为父类，其它两个类继承这个父类。

继承实现了面向对象的原则：write once,only once（编写一次、且编写一次

如何实现继承？

在java语言中，用extends（扩展）关键字来表示一个类继承了另一个类。

在父类中只定义一些通用的属性和方法。

子类自动继承父类的属性和方法，子类中可以定义特定的属性和方法。或子类重新定义父类的属性、重写父类的方法可以获得与父类不同的功能。

什么是方法重写？

如果在子类中定义的一个方法，其名称、返回类型及参数列表正好与父类中某个方法的名称、返回类型及参数列表相匹配，那么可以说，子类的方法重写了父类的方法。

方法重写在不同类，是实现多态的必要条件。

super关键字的用法和位置，super关键字调用父类的构造方法，super关键字调用父类的方法？

在子类的构造方法中，通过super关键字调用父类的构造方法。

如果子类中重写了父类的方法，可以通过super关键字调用父类的方法。

示例

父类：
private String name;
private String sex;

public xinxin1(String name,String sex) {
  this.name=name;
  this.sex=sex;
}
public void hello() {
  System.out.println(“嗨！我是”+name+”我是”+sex+”孩”);
}

子类：
public xinxin2(String name,String sex)
{
  //调用父类的构造方法
  super(name,sex);
}

public void hello() {
  System.out.println(“我是新来的！”);
  //调用父类的方法
  super.hello();
}

位置注意：调用父类的构造方法的语句（super语句）必须是构造方法中的第一条语句。

因为创建对象的时候，需要先创建父类对象，再创建子类对象。

注意：创建对象时，先创建父类对象，在创建子类对象。如果没有显示调用父类的构造方法，将自动调用父类的无参构造方法。

一切类的老大（祖先）Object。

所有类都直接或者间接地继承了java.lang.Object类，Object类中定义了所有的java对象都具有的相同行为，是所有类的祖先。

一个类如果没有使用extends关键字，那么这个类直接继承自Object类。

什么是多态？

多态的特征是表现出多种形态，具有多种实现方式。或者多态是具有表现多种形态的能力的特征。或者同一个实现接口，使用不同的实例而执行不同的操作。

为什么需要使用多态？多态的好处？

可以增强程序的可扩展性及可维护性，使代码更加简洁。

不但能减少编码的工作量，也能大大提高程序的可维护性及可扩展性。

如何实现多态？

一般做法是：写一个方法，它只接收父类作为参数，编写的代码只与父类打交道。调用这个方法时，实例化不同的子类对象（new 一个对象）。

更具体的说：

1. 子类重写父类的方法。使子类具有不同的方法实现。
2. 把父类类型作为参数类型，该父类及其子类对象作为参数转入。
3. 运行时，根据实际创建的对象类型动态决定使用那个方法。

在运行时，java虚拟机会根据实际创建的对象类型决定使用那个方法。一般将这称为动态绑定。

多态小结

多态与继承、方法重写密切相关，我们在方法中接收父类类型作为参数，在方法实现中调用父类类型的各种方法。当把子类作为参数传递给这个方法时，java虚拟机会根据实际创建的对象类型，调用子类中相应的方法（存在方法重写时）。