目录
内部类
实例内部类
package demo;
class OuterClass {
public int data1 = 1;
private int data2 = 2;
public static int data3 = 3;
/*
实例内部类:定义在类的内部 方法的外部
1.这个实例内部类到底怎么使用？
2.如何访问和外部类一样的成员属性？
* */
class InnerClass {
public int data1 = 100;
public int data4 = 4;
private int data5 = 5;
public static int data6 = 6;
public void test() {
System.out.println("InnerClass::test()");
System.out.println(data4);
System.out.println(data5);
System.out.println(data6);
System.out.println("==========");
System.out.println(data1);
System.out.println(OuterClass.this.data1);
//或者更直接的方式
/*OuterClass outerClass=new OuterClass();
System.out.println(outerClass.data1);*/
System.out.println(data2);
System.out.println(data3);
}
}
}
public class Test {
public static void main(String[] args) {
OuterClass out = new OuterClass();
OuterClass.InnerClass innerClass = out.new InnerClass();
innerClass.test();
}
}
1. 外部类中的任何成员都可以在实例内部类方法中直接访问
2. 实例内部类所处的位置与外部类成员位置相同，因此也受public、private等访问限定符的约束
3. 在实例内部类方法中访问同名的成员时，优先访问自己的，如果要访问外部类同名的成员，必须：外部类名称.this.同名成员 来访问
4. 实例内部类对象必须在先有外部类对象前提下才能创建
5. 实例内部类的非静态方法中包含了一个指向外部类对象的引用
6. 外部类中，不能直接访问实例内部类中的成员，如果要访问必须先要创建内部类的对象。
静态内部类
package demo;
class OuterClass2 {
public int data1 = 1;
private int data2 = 2;
public static int data3 = 3;
/*
静态内部类
1.如何生成静态内部类对象
2.不能直接调用外部类的非静态成员变量（实例成员变量）
* */
static class InnerClass {
public int data4 = 4;
private int data5 = 5;
public static int data6 = 6;
public void test() {
System.out.println("InnerClass::test()");
// System.out.println(data1);
// System.out.println(data2);
OuterClass2 outerClass2 = new OuterClass2();
System.out.println(outerClass2.data1);
System.out.println(outerClass2.data2);
System.out.println("===========");
System.out.println(data3);
System.out.println(data4);
System.out.println(data5);
System.out.println(data6);
}
}
public void testA() {
System.out.println("OuterClass::testA()");
}
}
public class Test2 {
public static void main(String[] args) {
OuterClass2 outerClass2 = new OuterClass2();
System.out.println(outerClass2.data1);
OuterClass2.InnerClass innerClass = new OuterClass2.InnerClass();
innerClass.test();
}
}
注意：内部类其实日常开发中使用并不是非常多，大家在看一些库中的代码时候可能会遇到的比较多，日常开始中使用最多的是匿名内部类
在静态内部类中只能访问外部类中的静态成员
如果确实想访问，我们该如何做？ 创建静态内部类对象时，不需要先创建外部类
局部内部类
package demo;
class OuterClass3 {
public int data1 = 1;
public void test() {
//局部内部类
class InnerClass {
public int data1 = 100;
public static int data2 = 2;
public void test() {
System.out.println("Inn::test()");
}
}
//局部内部类 只能在当前方法中使用
InnerClass innerClass = new InnerClass();
innerClass.test();
}
}
public class Test3 {
}
匿名内部类
//第一种
package demo;
interface ITestable {
void test();
}
public class Test4 {
public static void main(String[] args) {
new ITestable() {
@Override
public void test() {
System.out.println("test()........");
}
}.test();
}
}
//第二种
package demo;
interface ITestable {
void test();
}
public class Test4 {
public static void main(String[] args) {
ITestable it = new ITestable() {
@Override
public void test() {
System.out.println("test()........");
}
};
it.test();
}
}
异常
异常的体系结构
1. Throwable：是异常体系的顶层类，其派生出两个重要的子类, Error 和 Exception
2. Error：指的是Java虚拟机无法解决的严重问题，比如：JVM的内部错误、资源耗尽等，典型代表：StackOverflowError和OutOfMemoryError，一旦发生回力乏术。
3. Exception：异常产生后程序员可以通过代码进行处理，使程序继续执行。比如：感冒、发烧。我们平时所说的异常就是Exception。
异常的分类
编译时异常
在程序编译期间发生的异常，称为编译时异常，也称为受检查异常(Checked Exception)
运行时异常
在程序执行期间发生的异常，称为运行时异常，也称为非受检查异常(Unchecked Exception)
RunTimeException以及其子类对应的异常，都称为运行时异常。比如：NullPointerException、
ArrayIndexOutOfBoundsException、ArithmeticException。
注意：编译时出现的语法性错误，不能称之为异常。例如将 System.out.println 拼写错了, 写成了
system.out.println. 此时编译过程中就会出错, 这是 "编译期" 出错。而运行时指的是程序已经编译通过得到class 文件了, 再由 JVM 执行过程中出现的错误
异常的处理
防御型编程
1. LBYL: Look Before You Leap. 在操作之前就做充分的检查. 即：事前防御型
boolean ret = false;
ret = 登陆游戏();
if (!ret) {
处理登陆游戏错误;
return;
}
ret = 开始匹配();
if (!ret) {
处理匹配错误;
return;
}
ret = 游戏确认();
if (!ret) {
处理游戏确认错误;
return;
}
ret = 选择英雄();
if (!ret) {
处理选择英雄错误;
return;
}
ret = 载入游戏画面();
if (!ret) {
处理载入游戏错误;
return;
}
......缺陷：正常流程和错误处理流程代码混在一起, 代码整体显的比较混乱。
2.EAFP: It's Easier to Ask Forgiveness than Permission. "事后获取原谅比事前获取许可更容易". 也就是先操作, 遇到问题再处理. 即：事后认错型
try {
登陆游戏();
开始匹配();
游戏确认();
选择英雄();
载入游戏画面();
...
} catch (登陆游戏异常) {
处理登陆游戏异常;
} catch (开始匹配异常) {
处理开始匹配异常;
} catch (游戏确认异常) {
处理游戏确认异常;
} catch (选择英雄异常) {
处理选择英雄异常;
} catch (载入游戏画面异常) {
处理载入游戏画面异常;
}
......
优势：正常流程和错误流程是分离开的, 程序员更关注正常流程，代码更清晰，容易理解代码
异常处理的核心思想就是 EAFP。
异常的抛出
在编写程序时，如果程序中出现错误，此时就需要将错误的信息告知给调用者，比如：参数检测。
在Java中，可以借助throw关键字，抛出一个指定的异常对象，将错误信息告知给调用者。具体语法如下：
throw new XXXException("异常产生的原因");
1. throw必须写在方法体内部
2. 抛出的对象必须是Exception 或者 Exception 的子类对象
3. 如果抛出的是 RunTimeException 或者 RunTimeException 的子类，则可以不用处理，直接交给JVM来处理
4. 如果抛出的是编译时异常，用户必须处理，否则无法通过编译
5. 异常一旦抛出，其后的代码就不会执行
异常的捕获
异常的捕获，也就是异常的具体处理方式，主要有两种：异常声明throws 以及 try-catch捕获处理。
异常声明throws
此时这个异常最终交给JVM处理了，但是JVM没有处理，他的处理方式就是直接崩溃！
try-catch捕获并处理
关于异常的处理方式
异常的种类有很多, 我们要根据不同的业务场景来决定.
对于比较严重的问题(例如和算钱相关的场景), 应该让程序直接崩溃, 防止造成更严重的后果
对于不太严重的问题(大多数场景), 可以记录错误日志, 并通过监控报警程序及时通知程序猿
对于可能会恢复的问题(和网络相关的场景), 可以尝试进行重试.
在我们当前的代码中采取的是经过简化的第二种方式. 我们记录的错误日志是出现异常的方法调用信息, 能很快速的让我们找到出现异常的位置. 以后在实际工作中我们会采取更完备的方式来记录异常信息.
【注意事项】
1. try块内抛出异常位置之后的代码将不会被执行
2. 如果抛出异常类型与catch时异常类型不匹配，即异常不会被成功捕获，也就不会被处理，继续往外抛，直到JVM收到后中断程序----异常是按照类型来捕获的
没有捕捉到对应的异常，此时交给JVM处理，程序就直接终止了。
3. try中可能会抛出多个不同的异常对象，则必须用多个catch来捕获----即多种异常，多次捕获
如果多个异常的处理方式是完全相同, 也可以写成这样：
catch (ArrayIndexOutOfBoundsException | NullPointerException e) {
...
}
如果异常之间具有父子关系，一定是子类异常在前catch，父类异常在后catch，否则语法错误：
finally
在写程序时，有些特定的代码，不论程序是否发生异常，都需要执行，比如程序中打开的资源：网络连接、数据库连接、IO流等，在程序正常或者异常退出时，必须要对资源进进行回收。另外，因为异常会引发程序的跳转，可能导致有些语句执行不到，finally就是用来解决这个问题的。
语法格式：
try{
// 可能会发生异常的代码
}catch(异常类型 e){
// 对捕获到的异常进行处理
}finally{
// 此处的语句无论是否发生异常，都会被执行到
}// 如果没有抛出异常，或者异常被捕获处理了，这里的代码也会执行
finally中的代码一定会执行的，一般在finally中进行一些资源清理的扫尾工作。
自定义异常类
Java 中虽然已经内置了丰富的异常类, 但是并不能完全表示实际开发中所遇到的一些异常，此时就需要维护符合我们实际情况的异常结构.
例如, 我们实现一个用户登陆功能.
public class Login {
private String userName = "admin";
private String password = "123456";
public static void loginInfo(String userName, String password) {
if (!userName.equals(userName)) {
}
if
(!password.equals(password)) {
}
System.out.println("登陆成功");
}
public static void main(String[] args) {
loginInfo("admin", "123456");
}
}此时我们在处理用户名密码错误的时候可能就需要抛出两种异常. 我们可以基于已有的异常类进行扩展(继承), 创建和我们业务相关的异常类
具体方式：
1. 自定义异常类，然后继承自Exception 或者 RunTimeException
2. 实现一个带有String类型参数的构造方法，参数含义：出现异常的原因
class UserNameException extends Exception {
public UserNameException(String message) {
super(message);
}
}
class PasswordException extends Exception {
public PasswordException(String message) {
super(message);
}
}此时我们的 login 代码可以改成
public class Login {
private String userName = "admin";
private String password = "123456";
public static void loginInfo(String userName, String password)
throws UserNameException, PassWordException {
if (!userName.equals(userName)) {
throw new UserNameException("用户名错误！");
}
if (!password.equals(password)) {
throw new PassWordException("用户名错误！");
}
System.out.println("登陆成功");
}
public static void main(String[] args) {
try {
loginInfo("admin", "123456");
} catch (UserNameException e) {
e.printStackTrace();
} catch (PassWordException e) {
e.printStackTrace();
}
}
}自定义异常通常会继承自 Exception 或者 RuntimeException
继承自 Exception 的异常默认是受查异常
继承自 RuntimeException 的异常默认是非受查异常
3449
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
