面向对象（下）
1.类的继承
在现实生活中，继承一般指的是子女继承父辈的财产。在程序过程中，继承描述的是事物之间的所属关系，通过继承可以使多种事物之间形成一种关系体系。例如，猫和狗都属于动物，程序中便可以描述为猫和狗继承自动物。
在Java中，类的继承是指在一个现有类的基础上去构建一个新的类，构建出来的新的类被称为子类，现有的类被称为父类，子列会自动拥有父类的属性和方法。在程序中，如果想声明一个类继承另一个类，需要使用extends关键字。
继承使用的关键字
extends
格式:
class A extends B {
}
A类是B类的一个子类
B类是A类的唯一父类
Java中的继承是一个单继承模式
基本要求:
1. 子类继承父类之后，可以使用父类的非私有化成员变量和成员方法
【非私有化成员】
2. 子类不能继承得到父类的私有化内容。
子类可以对父类的方法进行重写，但是方法名要与所重写的父类方法名一致。
class Father {
// public修饰的公开成员变量name
public String name;
// private修饰的私有化成员变量salary
private double salary;
public Father() {
System.out.println("Father类构造方法");
}
public Father(String name, double salary) {
this.name = name;
this.salary = salary;
}
/*
* public修饰的公开方法
*/
public void game() {
System.out.println("黄金矿工");
}
private void testPrivate() {
System.out.println("父类私有化方法");
}
}
/*
* Son类是Father类的一个子类
* Father类是一个Son类的唯一父类
*/
class Son extends Father {
int age;
public Son() {
System.out.println("Son类的构造方法");
}
public void work() {
System.out.println("我是一个学生");
}
}
public class Demo1 {
public static void main(String[] args) {
Son son = new Son();
// 可以使用自定义的成员变量和成员方法
son.age = 16;
son.work();
// 通过继承之后，可以获取到父类中的非私有化成员变量和成员方法
son.name = "张三";
son.game();
}
}
super关键字：
1.使用super关键字访问父类的成员变量和成员方法。
具体格式如下：
super.成员变量
super.成员方法(参数)
2.使用super关键字访问父类的构造方法
格式：
super（参数）
2.接口
2.1生活中的接口
生活中比较常见的接口:
USB接口，国标插座，Type-C, 3.5MM, ARJ45, Lighting接口, HDMI, VGA, SATA, M.2, DisplayPort，雷电口， PCI-E
这些接口有什么作用?
USB接口 USB-A
1. 鼠标连接，键盘连接，声卡连接，麦克风，摄像头，补光灯，U盘，移动硬盘
2. 规范，都是USB设备
3. 设备本身决定了，要做什么事情。
2.2 Java中接口使用
格式：
interface 接口名 {
成员变量
成员方法
}
类【遵从】接口
implements
class 类名 implements 接口 {
}
接口中成员变量和成员方法缺省属性原因
从生活角度
USB接口规定了尺寸和连接方式，但是该接口做什么内容，是由设备决定的！！！
尺寸是固定 ==> 成员变量 缺省属性是public static final
设备做什么事情，不管但是规定连接方式 ==> 成员方法，需要设备自己完成
缺省属性 public abstract修饰
2.3接口使用总结
-
接口中的
成员变量缺省属性 public static final
成员方法缺省属性 public abstract -
一个非abstract类遵从interface接口，需要强制完成接口中所有缺省属性为public abstract的成员方法
-
接口和接口之间，允许使用extends关键字继承，并且允许一个接口，继承多个接口
interface A extends B, C
生活中: 协议直接的向下兼容问题 -
接口中可以使用default关键字修饰方法，default方法拥有方法体，可以认为是非强制实现方法，不要求遵从接口的非abstract强制实现，JDK1.8新特征
/*
* 接口演示
*/
/**
* 接口A
*
* @author Anonymous
*/
interface A {
// 【缺省属性】public static final
int num = 10;
// 【缺省属性】public abstract
void test();
}
interface B {
void testB();
}
/**
* TypeA 类遵从接口A
*
* @author Anonymous
*/
class TypeA implements A, B {
@Override
public void test() {
System.out.println(num);
System.out.println("TypeA遵从接口A，实现接口A中缺省属性为abstract的成员方法");
}
@Override
public void testB() {
System.out.println("TypeA同时遵从接口B，实现接口B中缺省属性为abstract的成员方法");
}
}
public class Demo1 {
public static void main(String[] args) {
TypeA typeA = new TypeA();
typeA.test();
}
}
3.多态
在Java中，允许使用一个父类类型的变量来引用一个子类类型的对象，根据被引用子类对象的特征的不同，得到不同的运行结果。接下来通过一个案列来演示多态的使用。
/*
从生活中映射USB接口
interface USB
规定USB设备必须完成的方法
void connect();
鼠标类 implements USB
鼠标是一个USB设备，必须完成connect方法
键盘类 implements USB
键盘是一个USB设备，必须完成connect方法
*/
/**
* USB接口
* @author Anonymous
*
*/
interface USB {
/**
* 要求所有的USB设备，必须完成的方法，告知USB接口连接之后完成的
* 功能是什么
*/
void connect();
}
/**
* 鼠标类，遵从USB接口，实现connect方法
*
* @author Anonymous
*/
class Mouse implements USB {
@Override
public void connect() {
System.out.println("鼠标连接USB接口，控制光标");
}
}
/**
* Logi类，继承Mouse鼠标类
* 1. 鼠标设备
* 2. Logi间接遵从USB接口，是一个USB设备
* @author Anonymous
*
*/
class Logi extends Mouse {
@Override
public void connect() {
System.out.println("Logi Master 2S");
}
}
/**
* 键盘类，遵从USB接口，实现connect方法
*
* @author Anonymous
*/
class Keyboard implements USB {
@Override
public void connect() {
System.out.println("键盘连接USB接口，输入设备");
}
}
/**
* IKBC继承Keyboard类
* 1. 键盘设备
* 2. 间接遵从USB接口，也是一个USB设备
* @author Anonymous
*
*/
class IKBC extends Keyboard {
@Override
public void connect() {
System.out.println("IKBC C87 静音红轴");
}
}
/**
* PC电脑类，使用USB接口，这里需要通过USB接口连接一个USB设备
*
* @author Anonymous
*/
class PC {
/**
* 电脑类连接USB接口连接方法，这里需要的是一个USB设备
*
* @param usb USB接口对应的设备
*/
public void usbConnect(USB usb) {
// usb设备执行connect方法
usb.connect();
}
}
public class Demo1 {
public static void main(String[] args) {
// 电脑中有一个方法是使用USB接口连接USB设备
PC pc = new PC();
// 鼠标和键盘都是USB设备
Mouse mouse = new Mouse();
Keyboard keyboard = new Keyboard();
// 电脑需要通过USB接口连接USB设备，mouse鼠标就是USB设备
pc.usbConnect(mouse);
// keyboard键盘也是USB设备
pc.usbConnect(keyboard);
// 传入一个Logi类对象
pc.usbConnect(new Logi());
// 传入一个IKBC类对象
pc.usbConnect(new IKBC());
}
}
4.异常（Exception）
从这个图中就可以看出
1.运行时异常是数组越界、空指针、类转换错误之类的异常，解决方法是修 改代码
2.而其他异常，也就是已检查异常，则是需要抛出或者捕捉
转载于:https://www.cnblogs.com/dolphin007/p/4446105.html
4.1异常处理
捕获异常：
try - catch 结构
try - catch - finally 结构 后期设计到资源问题，再讲解
格式:
try {
// 有可能出现异常代码
} catch (/* 对应处理的异常对象 */) {
// 处理方式
}
public class Demo3 {
public static void main(String[] args) {
test(10, 2, null);
}
public static void test(int num1, int num2, int[] arr) {
int ret = 0;
try {
ret = num1 / num2;
System.out.println("测试代码");
arr[0] = 10;
} catch (ArithmeticException e) {
e.printStackTrace();
} catch (NullPointerException e) {
e.printStackTrace();
}
System.out.println("ret:" + ret);
}
}
4.2抛出异常
throw
在方法内抛出异常
throws
在【方法声明】位置，告知调用者当前方法有哪些异常抛出
声明的异常需要生成对应的文档注释
/*
* 抛出异常总结:
* 1. 一个代码块内，有且只能抛出一个异常
* 2. 从throw位置开始，之后的代码不在运行
* 3. 代码中存在使用throw抛出异常，在方法的声明位置必须告知调用者这里有什么异常
*
*/
public class Demo4 {
// 调用带有异常抛出的方法，如果选择继续抛出需要在当前方法的声明位置
// 告知其他调用者，这里有什么异常抛出
public static void main(String[] args)
throws NullPointerException, ArithmeticException {
// 调用一个带有异常抛出的方法
// 捕获处理
try {
test(10, 2, null);
} catch (ArithmeticException e) {
System.out.println(e.getMessage());
} catch (NullPointerException e) {
System.out.println(e.getMessage());
}
// 可以继续抛出异常
test(10, 0, null);
}
/**
* 测试方法
*
* @param num1 int类型
* @param num2 int类型
* @param arr int类型数组
* @throws ArithmeticException 除数不能为0
* @throws NullPointerException 操作数组null地址异常
*/
public static void test(int num1, int num2, int[] arr)
throws ArithmeticException, NullPointerException {
// 参数合法性判断
/*if (0 == num2 || null == arr) {
System.out.println("Input Parameter is Invalid!");
return;
}*/
// 抛出异常方式来处理当前的参数合法性判断
if (0 == num2) {
// 有可能会导致算术异常
throw new ArithmeticException("算术异常");
}
if (null == arr) {
// 存在数组操作空指针异常
throw new NullPointerException("数组空指针异常");
}
System.out.println(num1 / num2);
arr[0] = 10;
}
}
