文章目录

L11
- 1 统一与变化的和谐--抽象类
- - (1) 抽象方法的作用
  - (2) 抽象方法和抽象类
  - (3) 抽象类编程思想与实现过程
- 2 内部类
- - (1) 内部类
  - (2) 匿名内部类
  - (3) 匿名内部类的优点
  - (4) 抽象类的具体实现方式视情况而定
- 3 高度抽象--接口
- - (1) 接口 interface
  - (2) interface的基本语法
  - (3) 接口的实现--implements
  - (4) Java的单类继承和多接口实现
  - (5) 接口的特点
L12
- 1 Java的异常处理
- - (1) 基本异常处理语法和过程
  - (2) 运行时异常和非运行时异常
  - (3) 自定义异常
  - (4) 异常中的finally
  - (5) 异常抛出和捕获的选择

L11

1 统一与变化的和谐–抽象类

(1) 抽象方法的作用

在L8的继承中，讨论了继承是自顶向下还是自底而上的问题，最后得出的结论是：在具体编程过程中，通常采用了自底而上的方式，在众多类中抽象出类似或雷同的部分来构建基类

考虑下面的问题
对几种几何图形的属性和简单计算：

长方形成员：名称，长，宽方法：输出，周长，面积
正方形成员：名称，边长方法：输出，周长，面积
圆成员：名称，半径方法：输出，周长，面积

对于上述的3个类，通过观察可以发现它们都有名称成员，都有输出，周长，面积的计算方法，将这些共同点抽取出，可以构成一个基类Shape类，对于长方形的成员，正方形的成员，圆的成员可以在各自的类中单独定义，然后让长方形类，正方形类，圆类派生于Shape类就完成了一次自底向上的抽象过程

在Shape类的具体实现中发现，输出名称是确定无疑的，这个方法完全可以在Shape类中实现，子类直接继承Shape调用即可，但是周长和面积的计算对于3种几何图形各自不同，无法在Shape中统一实现

对于任何形状都存在着周长和面积的要求，确定每种形状都必须实现计算周长和面积，这其中存在着 统一和变化

统一：每种图形都必须有周长和面积的计算
变化：不同图形的周长和面积的计算各有不同

java为了处理这样的问题，提出了抽象方法

(2) 抽象方法和抽象类

用关键字abstract修饰一个方法，并且只声明而不具体实现这个方法，就可以生成一个抽象方法

//声明计算周长和计算面积的抽象方法
public abstract double perimeter();
public abstract double area();

包含至少一个抽象方法的类，必须用abstract修饰称为抽象类

抽象类是不能实例化的，因为抽象类存在未实现的方法，由这个抽象类派生出的子类，如果依然没有实现其抽象方法，则这个子类也是抽象类

由Shape类派生出的Square类：

由Shape类派生出的Rectangle类：

(3) 抽象类编程思想与实现过程

抽象类通常是在很多类的基础上进行抽象形成的，因此抽象类由确定的成分和不确定的成分组成

确定的成分：通常指那些类中固定的，固有的和确定的成员和方法，这些成分在抽象类中实现，再用派生的方式让子类继承，从而实现了代码复用

不确定的成分：是那些类彼此大致相同但具体实现又不同的部分，相同点在于这些类都存在这些成分，不同点在于这些成分的具体实现方法有所不同

抽象类的实现过程：
1，通过继承抽象类，并实现其抽象方法，产生子类
2，在子类中实现抽象方法，完成具体需求

2 内部类

(1) 内部类

在一个类中，可以定义其他类，这些类称为内部类

内部类所在的类称为“外部类”，内部类可以直接引用外部类的成员和方法，不受权限修饰符的限制，外部类的方法可以通过内部类的对象引用内部类的所有成员和方法

package com.mec.about_innerclass;public class OuterClass {//定义三种不同权限修饰符的成员private int privateMember;protected int protectedMember;public int publicMember;public OuterClass() {privateMember = 1;protectedMember =2;publicMember = 3;}//定义三种不同权限修饰符的方法private void privatefun() {System.out.println(privateMember);}protected void protectedfun() {System.out.println(protectedMember);}public void publicfun() {System.out.println(publicMember);}/*** OuterClass的内部类* @author coisini1999*/public class InnerClass {private int innerMember;public InnerClass() {innerMember = 4;}//内部类中可以直接使用外部类的所有成员和方法//且不受权限修饰符的限制private void innerfun() {privateMember++;protectedMember++;publicMember++;privatefun();protectedfun();publicfun();}}//外部类可以定义内部类对象的成员private InnerClass innerObject;//外部类的方法可以通过内部类的对象引用内部类//的所有成员和方法public void fun() {innerObject = new InnerClass();innerObject.innerfun();System.out.println(innerObject.innerMember++);}}

内部类.class文件存放的位置：

(2) 匿名内部类

先看一个简单的抽象类：

对于这个抽象类，现在不用再派生子类(各种品种的鸟)来完成cry的抽象方法，而是直接在此类中进行 “实例化”，这里的实例化会引出一个问题：抽象类没有完成抽象方法的具体实现是不能直接实例化的，但是可以 “非直接实例化”

     Bird lark = new Bird("百灵鸟") {        @Overridepublic String shout() {return "婉转";}    };lark.print();上述代码的书写格式很独特：
new 抽象类构造方法() {实现该抽象类的所有抽象方法
};
其本质是生成了一个类，不过这个类没有机会命名
所以该类称为 匿名内部类，但它会生成相应的类文件

     new Bird("乌鸦") {@Overridepublic String shout() {return "刺耳";}  }.print();上述写法的本质是先产生一个匿名内部类
这里的写法连匿名类的对象名都省略了
new关键字返回的实例的首地址就是对象
所以new的返回结果就是这个类的对象，当然可以.print()调用它的方法

Test是该测试类，Test$1和Test$2是Test的匿名内部类，1和2是java编译器自动加上去的，这就是匿名的名称形式，用以区分不同的匿名内部类

(3) 匿名内部类的优点

1，不需要明确地产生派生类，这对于简单问题，明显提高了编程效率
2，在需要的时候临时产生匿名内部类，实现抽象方法，这样更灵活
3，一个匿名内部类对应一种抽象方法的实现，这样更紧凑

(4) 抽象类的具体实现方式视情况而定

抽象类具体怎么使用，应根据情况而定，没有非常固定的方式，如果派生类简单，可以使用匿名内部类实现抽象类的抽象方法，如果派生类有庞杂的不同于抽象类的成员和方法，还是需要派生子类，在子类中实现抽象类的抽象方法

匿名内部类连名字都没有，就更不用提构造器了，以及在其中定义变量，这些变量都无法被初始化，更不可能被匿名内部类产生的对象调用，所以仅将匿名内部类用于简单用途

3 高度抽象–接口

(1) 接口 interface

interface即接口，交界面。在程序设计中接口可以特指“函数三要素”，即函数名称，参数和函数返回值类型，当规定了某个函数的接口，同时规定了函数的功能，但是不规定函数功能的具体实现过程(不关心内部编码)，那么这个函数就被认为是 “已经确定的函数”

这样已经确定了接口的函数，可以在任何需要它的地方调用它，而不用关心它内部的实现原理(C中使用printf，scanf)，这使得，基于“接口”所编写的代码，在功能实现过程发生改变时，只要接口不变，应用层代码无需变动，这十分有利于技术的更新换代，也利于代码的维护(由于应用层代码不变，就不需要测试，维护成本)

接口在java中可以与继承平起平坐，java非常多的设计技巧都基于接口和继承这两种功能，java设计原则有一条就是 面向接口编程

(2) interface的基本语法

接口类似于类，但与类相比，需要遵守两个原则：
1，接口中的成员只能是公有，静态，常量，即成员必须是public static final联合属性

2，接口中的方法只能是公有，抽象方法，即方法必须是
public abstract联合属性

在接口中如果不声明联合属性，会默认添加成员和方法的联合属性

上述两个成员和方法的本质是一样的，一般情况下
使用InterfaceOne的方式

(3) 接口的实现–implements

接口不同于类，其使用方式是通过实现来完成的，实现对应一个关键字"implements"，通常建立一个类，该类实现一个或多个接口，从而达到使用接口的目的

先定义两个接口：

创建一个实现上述两个接口的类：

注意一条语句：

public class SomeClass implements Ipriceable,IShapeable

SomeClass同时实现了两个接口，在implements关键字后，两个接口用逗号分隔，这一点不同意类的继承，Java中只能单类继承，但允许实现多接口

实现接口的类，必须实现接口内的抽象方法，否则该类就是抽象类

下面给一个Demo类，演示一些类对象和接口间的“继承”关系：

实现了接口的类的对象，一定能调用接口规定的所有方法

(4) Java的单类继承和多接口实现

java在类的继承时不允许同时继承多个基类，但是可以实现多个接口

在java出现前，面向对象程序设计语言已经存在，如C++，C++虽然功能强大，但太过复杂，C++保持了C中的指针，C++允许多重继承，C++除了允许函数重载外还允许运算符重载，这些原理复杂，功能强大的手段，对使用者的要求是极高的

java开发者在开发java时，核心诉求之一就是研发一种更简单，更容易掌握，更不容易出错的面向对象程序设计语言，在java中不允许多继承，是为了避免多继承带来的基类成员冲突的问题，拒绝指针，从根源上杜绝了“参数引用传递”的手段，且避免了实例化构造方法出现递归，且java提出了GC，从根源上杜绝了内存泄漏这个问题

java的单继承虽然有部分性能上的损失，此设计了多接口实现，弥补了性能上的缺失

(5) 接口的特点

1，海纳百川类型的统一和保护

java处处都是类，随着java程序的不断增加，类的不断生成，java的数据类型也在不断扩容，面对如此庞大的数据类型群，对于某些场合会带来灾难性的后果

如果想要将Complex类，Circle类，Square类，Gold类，Silver
类的对象按照字符串：对象的方式采用HashMap存储到Map中，且禁止其它类的对象存储到Map中

在不用接口的情况下，可以使用Object类，描述所有对象类型，但是用Object类完成后，如果需要增加或删除一个类，那么需要更改大量的代码，完成后还需要进行各种测试

这种问题是因为“类型保护的缺失”造成的，使用接口可以轻松解决：

定义一个接口
package com.mec.interface;public interface IMyType {}

然后修改能进入Map的类，使它们实现这个接口，再定义一个HashMap，其值为这个IMyType接口类型：

HashMap<String,IMyType> myMap = new HashMap<>();

之后，在对myMap进行操纵时，只有值得类型满足是IMyType的派生类对象才可以进入，不要小看了空接口

2，政令统一规范方法

凡是实现了该接口的非抽象类，就必须实现这个接口所规定的所有抽象方法

这个规则包含着规范行为的意义，比如在某种场合下，我们需要某些类实现我们固定要求实现的一些方法，那么可以将这些方法写进一个接口，让这些类实现这个接口，这时，这些类就必须实现这些方法，且全部实现，一个都不能少，一个都不能改

规范体现在：
1，指定的所有方法都必须实现，一个都不能少
2，规范了方法的名称
3，规范了方法的参数个数和参数类型
4，规范了方法的返回值类型

3，广而告之方法的公开

从规范方法的应用角度看这个问题，我们得知某些类实现了某个接口，那么这些列就一定存在接口中的方法，就可以调用这些方法

4，面向未来分离原则

当面对某些问题未来有不止一种实现过程时，也可以使用接口，如对不同渠道传来的数据进行排序，如从键盘输入的数据，从文件中读入的数据，从数据库中导入的数据，从网络中得到的数据

对于未来工具的使用者要处理何种渠道传来的数据，我们是不知道的，且允许数据不仅从一种渠道得到

可以使用接口设置输入数据的类型，将数据输入作为排序的一个成员，需要处理什么渠道的成员，就让它实现定好的接口

L12

在C语言中，一段具有实际应用意义的代码中往往需要大量的错误判断，处理特殊情况的代码，即程序中有着许多 if-else来处理不确定的情况，避免程序崩溃

因为具有实际意义的软件本身是复杂的，软件的运行环境也是复杂的，加之软件使用者在操作时的不确定性和不可控性，使得程序在运行时出现不正常，甚至导致程序崩溃的情况在所难免，为了尽量减少这些异常的出现，程序员需要使软件具有鲁棒性

鲁棒(robust)：即健壮，强壮的意思，它是在异常和危险情况下系统生存的关键，如计算机在输入错误，磁盘崩溃，网络过载或有意攻击下，能否不死机，不崩溃就是该软件的鲁棒性

1 Java的异常处理

(1) 基本异常处理语法和过程

先看下面的例子：

这个程序当然不能执行，不过在控制台出现了异常提示，清楚的说明了异常类型和发现异常的位置，这说明，除0错误，是被java系统捕获并处理了，只不过java处理它的方式是输出异常的具体信息

上述的程序证实了当异常发生且程序员不做处理时，则之后的代码都将会停止，程序无法继续运行

对于上述的程序，我们也可以自己捕获并处理这个异常：

上面的例子说明了关于java异常处理的基本原则：
1，程序一旦发生异常，则异常点后的所有代码都停止执行，如果不存在这种异常的捕获语句，则以后的代码都将会停止执行，程序崩溃，由JVM接手处理

2，如果存在try { } catch() { } 捕获了异常，则转而执行异常捕获语句块中的代码，接下里继续执行异常捕获语句块后的代码，程序不会崩溃

不同情况下的程序流程：

(2) 运行时异常和非运行时异常

java内部已经定义了很多异常，这些异常分为两大类：运行时异常和非运行时异常

异常类的继承结构：

运行时异常和非运行时异常最大的区别在于：编译器要求程序员必须对非运行时异常进行捕获，否则不能通过编译

对于先前的除0错误所属的ArithmeticException类，就属于运行时异常，编译器没有强制要求捕获这类异常，而大部分异常都是非运行时异常，编译器提示程序员必须对这类异常进行处理，这样可以消除因为程序员的遗漏而造成代码潜在的危险

我们还可以根据自己的需要，生成自己的异常类，这极大的扩展了异常的应用范围，方便了软件的开发

(3) 自定义异常

用Exception类可以派生出非运行时异常
用RuntimeException类可以派生出运行时异常

通常建议定义非运行时异常，这样可以强迫程序员对异常进行捕获和处理，如果不需要程序员有目的的进行捕获，也可以定义运行时异常

自定义一个异常类，在定义该异常类时要继承父类的构造方法和生成序列号：

对于该自定义异常的使用：

package com.mec.point;import com.mec.about_Exception.OutOfRangeException;public class Point {private int row;private int col;public static final int MIN_ROW =1;public static final int MAX_ROW = 25;public static final int MIN_COL =1;public static final int MAX_COL = 80;public void setRow(int row) throws OutOfRangeException {if(row < MIN_ROW || row > MAX_ROW) {throw new OutOfRangeException("行下标越界");}this.row = row;}public void setCol(int col) throws OutOfRangeException {if(col < MIN_COL || col > MAX_COL) {throw new OutOfRangeException("列下标越界");}this.col = col;}public Point(int row, int col) throws OutOfRangeException {setRow(row);setCol(col);}public Point() throws OutOfRangeException {this(1,1);}public int getRow() {return row;}public int getCol() {return col;}}

(4) 异常中的finally

异常处理中还有一个关键字：finally，它的作用是，无论异常是否发生，都要执行的块

finally中的关闭资源，无论是否发生了ArithmeticException异常，都要执行

finally块的存在主要为了在异常发生时，能完成一些必要的操作，如关闭资源等在某些场合尤为重要的操作

(5) 异常抛出和捕获的选择

能处理则处理，不能处理则抛出

对于异常，主要有两种处理手段：抛出和捕获

一般来说，如果对于某种异常，如果在本方法中有处理它的安排且这个异常不影响调用它的方法，那么就捕获，相当于自动响应这个异常，给出了有效处理

如果这种异常严重影响到了后续代码的逻辑和执行，甚至会影响到调用它的方法，那么就把这个异常抛出，当然直到抛到主函数那里还是需要处理一下

JAVA SE 基础篇 L11-L12相关推荐

java实现linkstring,【JAVA SE基础篇】32.String类入门
[JAVA SE基础篇]32.String类入门 1.字符串 1.String类又称作不可变字符序列 2.String位于java.lang包中,java程序默认导入java.lang包下所有的类 3 ...
java 中间容器表格_【JAVA SE基础篇】45.迭代器、Collections工具类以及使用容器存储表格...
本文将要为您介绍的是[JAVA SE基础篇]45.迭代器.Collections工具类以及使用容器存储表格,具体完成步骤: 1.迭代器迭代器为我们提供了统一遍历容器(List/Map/Set)的方式 ...
java se运算符优先级,【JAVA SE基础篇】10.运算符优先级与类型转换
[JAVA SE基础篇]10.运算符优先级与类型转换 1.运算符的优先级运算符的优先级在考试中会考,了解即可,多用就会熟能生巧实际使用过程中建议用小括号来分优先级关键就是:逻辑非>逻辑与& ...
java se用哪个eclipse_【JAVA SE基础篇】5.eclipse的使用和运行
1.eclipse的版本介绍所有版本的eclipse都按照系统分为32位和64位,如果你的JDK是32位,eclispe必须也是32位,eclipse应与JDK相符合 eclipse分SE和EE等版 ...
零基础入门自学 JAVA SE 基础篇（九）instanceof final 开闭原则多态抽象(abstract)方法与抽象类接口(interface)
JAVA SE自学基础篇多态 instanceof final 开闭原则多态抽象(abstract)方法与抽象类接口(interface) 目标父类型与子类型之间的转换及instanceo ...
Java SE 基础篇总结（下）
6_多线程 6.1 程序.进程.线程的理解程序(programm) 概念:是为完成特定任务.用某种语言编写的一组指令的集合.即指一段静态的代码. 进程(process) 概念:程序的一次执行过程,或 ...
Java SE 基础篇大全（Java 入门必看）
第一章 java由来.环境搭建一.Java历史[了解] 1. 1995.5.23 sun推出的一款面向对象的编程语言. 2. Java的发展方向:JavaSE(Java的语言基础).Java ...
java中file类乱,【JAVA SE基础篇】47.file类的方法
1.file类的方法 1.getName():获取文件名 2.getPath():获取文件路径,设定是相对路径得到的就是相对路径,绝对路径同里 3.getAbsolutePath():获取文件绝对路径 ...
java unicode32_【JAVA SE基础篇】32.String类入门
1.字符串 1.String类又称作不可变字符序列 2.String位于java.lang包中,java程序默认导入java.lang包下所有的类 3.java字符串就是Unicode字符序列,例如字 ...

JAVA SE 基础篇 L11-L12