1.内部类
1.1什么是内部类？
将一个类定义在另一个类的里面，对里面的那个类就称为内部类（内置类，嵌套类）。
把类1定义到类2内部有什么好处呢？
如果把类1定义到外面的话，类2要用类1的功能属性什么的是不是要先创建类1的对象然后
才能调用类1中的东西啊，而把类1定义到类2中的话，要访问类1的内的东西，就不用创建
对象了。
内部类访问规则：
比如说孙悟空是个类，牛魔王也是个类，孙悟空要访问牛魔王的心脏，是不是要先获得牛魔王
的对象，然后再调用牛魔王的get心脏方法。但是如果孙悟空飞进了牛魔王的肚子里面，是不是
就能直接访问牛魔王这个类里面的东西啦？包括其私有的东西。这时候孙悟空就是个内部类，
牛魔王是外部类，孙悟空能直接访问牛魔王的类里的东西，而牛魔王要想访问孙悟空的心脏，是
不是要先获得孙悟空的对象啊，然后才能访问它的心脏。
内部类访问规则：
1.内部类可以直接访问外部类成员，包括私有的；之所以能访问是因为省略了 “外部类名.this”
2.外部类访问内部类需建立内部类对象
内部类访问格式：
当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。可以直接建立内部类对象。
格式为：外部类名.内部类名 变量名 = 外部类对象.内部类对象;
Outer.Inner in = new Outer().new Inner();
部分代码：
class Outer
{
int x=3;
void method()
{
Inter in = new Inter();//外部类访问内部类需建立内部类对象
in.show();//调用内部类中方法
}
class Inter//内部类
{
void show()
{
//内部类可以直接访问外部类中的成员
System.out.println("inter"+x);//打印外部类中成员变量x，同下句
System.out.println("inter"+Outer.this.x);//其实是省略了外部类名.this.
}
}
}
class InnerClassDemo
{
public static void main(String[] args)
{
//在外部其他类中直接访问内部类的成员
//Inner in = new Inner();这样不行，因为如果另一个类中也有一个名为Inner的内部类，
//这样写是不是就不知道这个Inner是哪个类中的内部类啦？
Outer.Inter in = new Outer().new Inter();//所以要这样创建，指出是哪个类的内部类
in.show(); //创建内部类对象，直接调用它的方法。
}
}
1.2 静态内部类：
a.成员内部类
当内部类在成员位置上，就可以被成员修饰符所修饰。比如：
private：将内部类在外部类中进行封装。
static:当内部类被static修饰后,它就具备了static的特性，能直接被外部类的类名调用，
并且只能直接访问外部类中的static成员。出现了访问局限。
在外部其他类中，如何直接访问static内部类的非静态成员呢？
new Outer.Inner().function();
因为是静态的了，所以能直接被外部类的类名调用，Outer.Inner()是内部类了，一new就行了。
在外部其他类中，如何直接访问static内部类的静态成员呢？
Outer.Inner.function();直接内部类类名调用
注意：当内部类中定义了静态成员，该内部类必须是static的。
当外部类中的静态方法访问内部类时，内部类也必须是static的。
部分代码如下：
class Outer
{
static int x=8;
static class Inter//当内部类中的方法有静态成员时，内部类也一定为静态
{
static void show()//当内部类被static修饰后,只能直接访问外部类中的static成员
{
System.out.println(x);
}
}
static void show()//当外部类的静态方法访问内部类时，内部类也必须为静态的
{
Inter in = new Inter();
in.show();
System.out.println("dangligedang ");
}
}
class OutClassDemo2
{
public static void main(String[] args)
{
//当静态内部类种方法为非静态时，要先创建内部类对象，在调用内部类中的非静态方法
new Outer.Inter().show();
//如果内部类中的方法为静态的，下面这种写法可以。
Outer.Inter.show();
}
}
内部类定义规则：
当描述事物时，事物的内部还有事物，该事物用内部类来描述。因为内部事务在使用外部
事物的内容。
b.局部内部类
内部类定义在局部时，
1，不可以被成员修饰符修饰，就把局部类当做一个局部变量，它是不需要被修饰符修饰的
2，可以直接访问外部类中的成员，因为还持有外部类中的引用。
但是不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量。
部分代码：
class Outer
{
int x = 3;
void method(final int a)
{
final int y = 4;
new Inner().function(); //这句只能放局部内部类下面，从上往下读，读到这还没内部类呢
class Inner//局部类不能被成员修饰符修饰
{
void function()
{
System.out.println(x);//能直接访问外部类的成员
System.out.println(y);//不能直接访问内部类所在局部的变量，除非被final修饰
}
}
new Inner().function(); //创建内部类对象，调用其方法
}
1.3.匿名内部类
匿名内部类是指没有指定类名的内部类，当某个类不需要重复使用时，就可以把该类定义为匿名内部类，
由于匿名内部类没有类名所以在程序中你只能使用一次。
匿名内部类:
1，匿名内部类其实就是内部类的简写格式。
2，定义匿名内部类的前提：
内部类必须是继承一个类或者实现接口。
3，匿名内部类的格式： new 父类或者接口(){定义子类的内容}
4，其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。 可以理解为带内容的对象。
5，匿名内部类中定义的方法最好不要超过3个。
部分代码：
abstract class AbsDemo
{
abstract void show();
}
class Outer
{
int x = 3;
public void function()
{
//Inner in = new Inner();
//in.show();
new AbsDemo()//定义一个匿名内部类
{
void show()
{
System.out.println("这里实现了接口中的方法");
}
}.show();//调用内部类中的show()方法。
}
}
----------------------------------------------------------------------------------------------------------------------------------------------------
2.异常
1.什么是异常？
异常就是程序在运行时出现不正常情况。
异常由来：问题也是现实生活中一个具体的事物，也可以通过java的类的形式进行描述并封装
成对象。其实就是java对不正常情况进行描述后的对象体现。
对于问题的划分：两种：一种是严重的问题，一种非严重的问题。
对于严重的，java通过Error类进行描述。对于Error一般不编写针对性的代码对其进行处理。
对与非严重的，java通过Exception类进行描述。对于Exception可以使用针对性的处理方式进行处理。
无论Error或者Exception都具有一些共性内容。比如：不正常情况的信息，引发原因等。
2.异常的处理格式：
try
{
需要被检测的代码；
}
catch(异常类 变量)
{
处理异常的代码；(处理方式)
}
finally
{
一定会执行的语句；如关闭资源，IO流什么的
}
3，对捕获到的异常对象进行常见方法操作。
Throwable中的方法
getMessage()获取异常信息，返回字符串。
toString()获取异常类名和异常信息，返回字符串。 ?
printStackTrace()获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。 ?
printStackTrace(PrintStream s)通常用该方法将异常内容保存在日志文件中，以便查阅。
3.声明异常 throws
在函数上声明异常。便于提高安全性，让调用出进行处理。不处理编译失败。
部分代码：
class Demo//3.所以这个程序的编写者要考虑到这一点
{
//5.所以这时候编写者就要在这声明一下说，这个功能使用时可能会出现问题你在用时要注意一下
int div(int a,int b)throws Exception//6.通过throws声明该功能可能会出问题，但是我解决
{ //不了,就抛给了使用者让使用者去处理
return a/b;//4.你写的这个程序中有除法功能,但是别人在用你写的这个功能时，人家往里
//传什么你是不知道的，所以要考虑到使用者有可能往里传除数为0的情况
}
}
class ExceptionDemo
{
public static void main(String[] args) //throws Exception 8.或抛
{
Demo d = new Demo();
//2.但是可处理可不处理,因为你用别人写的div功能时,根本就不知道这个功能会不会发生问题,你怎
//么处理,你用到的每一个功能会不会有问题你都不知道，你不会都挨个处理一遍吧
try
{
//7.这时候人家给你标出来了这个功能可能会出问题，使用者用时就要注意了，或try或抛
int x = d.div(4,1);//1.使用者传参数的时候可能会使程序停掉，比如除数为0
System.out.println("x="+x);
}
catch (Exception e)//Exception e = new ArithmeticException();
{
System.out.println("除零啦");
}
System.out.println("over");
}
}
4.多异常处理
在定义功能的时候，有时会发现这个功能可能出现的问题不止一个。
在进行多异常处理时应注意：
1，声明异常时，建议声明更为具体的异常。这样处理的可以更具体。
2，对方声明几个异常，就对应有几个catch块。不要定义多余的catch块。如果多个catch块
中的异常出现继承关系，父类异常catch块放在最下面。
建立在进行catch处理时，catch中一定要定义具体处理方式。不要简单定义一句 e.printStackTrace(),
也不要简单的就书写一条输出语句。
5.自定义异常
因为项目中会出现特有的问题，比如在你设计的功能中，除数也不能为负数。而这种情况并没有被
java所描述，这样的话就要自己定义了。
所以对于这些特有的问题可以按照java的对问题封装的思想。将特有的问题进行自定义的异常封装。
当在函数内部出现了throw抛出异常对象，那么就必须要给对应的处理动作。要么在内部try catch处理。
要么在函数上声明让调用者处理。一般情况下，函数内出现异常，函数上需要声明。
如何定义异常信息呢？
因为父类中已经把异常信息的操作都完成了。所以子类只要在构造时，将异常信息传递给父类通过
super语句。那么就可以直接通过getMessage方法获取自定义的异常信息。
总之，在自定义异常的时候，那个自定义类，要继承Exception或者其子类。并且通过构造函数自定义
异常信息，然后通过throw将自定义异常抛出。
例如：
class FuShuException extends Exception //自定义异常
{
FuShuException(String msg)//通过构造函数自定义异常信息
{
super(msg);//因为父类中都定义好了，直接拿来用就行了
}
}
class Demo
{
int div(int a,int b)throws FuShuException//在函数上声明抛出
{
if(b<0)//手动通过throw关键字抛出一个自定义异常对象。
throw new FuShuException("出现了除数是负数的情况");
return a/b;
}
}
class ExceptionDemo3
{
public static void main(String[] args)
{
Demo d = new Demo();
try//捕获异常并进行处理
{
int x = d.div(4,-9);
System.out.println("x="+x);
}
catch (FuShuException e)
{
System.out.println(e.toString());
}
}
}
throw与throws的区别是什么？
throw用于抛出一个异常类对象，通常用于自定义异常类情况，如throw new MyException().
并且是在函数内使用。它后面跟的是异常对象。
throws则是在方法声明时告诉调用者该方法会抛出哪些异常,而异常的捕获处理交给调用者
去处理。throws使用在函数上，它后面跟的是异常类。可以跟多个，用逗号隔开。
当函数内容有throw抛出异常对象，并未进行try处理。必须要在函数上声明，都在编译失败。
注意，RuntimeException除外。也就说，函数内如果抛出的RuntimeExcpetion异常，函数上
可以不用声明。
6.运行时异常：RuntimeException
异常有两种：
编译时被检测异常
该异常在编译时，如果没有处理(没有抛也没有try)，编译失败。该异常被标识，代表
这可以被处理。
运行时异常(编译时不检测 RuntimeException以及其子类)
在编译时，不需要处理，编译器不检查。该异常的发生，建议不处理，让程序停止。
需要对代码进行修正
如果在函数内抛出RuntimeException异常，函数上可以不用声明，编译一样通过。
如果在函数上声明了RuntimeException异常。调用者可以不用进行处理。编译一样通过；
之所以不用在函数声明，是因为不需要让调用者处理。当该异常发生，希望程序停止。因为在
运行时，出现了无法继续运算的情况，希望停止程序后，对代码进行修正。
自定义异常时：如果该异常的发生，无法在继续进行运算，就让自定义异常继承RuntimeException。
部分代码：
class Demo
{
//3.编写者的意思就是当调用者传入的参数非法时就让程序停下来，这样就没必要把异常抛给调用者了
int div(int a,int b)//throws ArithmeticException4.因为抛的意思就是让调用者知道哪错了，
{ //然后让调用者去处理
//1.在写这个功能发现调用者可能传入非法参数,这时就抛出一个运行时异常ArithmeticException
if(b==0)//2.抛这种异常的意思是,你敢传非法参数我就敢让程序停下来,你传对了再继续用
throw new ArithmeticException ("被零除啦");
return a/b;
}
}
class ExceptionDemo4
{
public static void main(String[] args)
{
Demo d = new Demo();
//5.这样调用者就不知道这个功能有异常,他也就不会进行try处理了
int x = d.div(4,0);//6.这样的话当调用者传除数为0的时候，能编译成功，但是会运行出错
//调用者想要程序运行成功，这时就必须传一个正确的数了
System.out.println("x="+x);
}
}
异常体系：
Throwable
|--Error
|--Exception
|--RuntimeException
异常体系的特点：异常体系中的所有类以及建立的对象都具备可抛性。也就是说可以被throw和
throws关键字所操作。只有异常体系具备这个特点。
异常的好处：
1，将问题进行封装。
2，将正常流程代码和问题处理代码相分离，方便于阅读。
异常的处理原则：
1，处理方式有两种：try 或者 throws。
2，调用到抛出异常的功能时，抛出几个，就处理几个。一个try对应多个catch。
3，多个catch，父类的catch放到最下面。
4，catch内，需要定义针对性的处理方式。不要简单的定义printStackTrace，输出语句。
也不要不写。
当捕获到的异常，本功能处理不了时，可以继续在catch中抛出。
try
{
throw new AException();
}
catch (AException e)
{
throw e;
}
如果该异常处理不了，但并不属于该功能出现的异常。
可以将异常转换后，在抛出和该功能相关的异常。
或者异常可以处理，当需要将异常产生的和本功能相关的问题提供出去，
当调用者知道。并处理。也可以将捕获异常处理后，转换新的异常。
try
{
throw new AException();
}
catch (AException e)
{
// 对AException处理。
throw new BException();
}
异常的注意事项：
异常在子父类覆盖中的体现；
1，子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的
异常或者该异常的子类。
2，如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子集。
3，如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常。
如果子类方法发生了异常。就必须要进行try处理。绝对不能抛。
部分代码：
class Fu
{
void show()throws AException
{
}
}
class Test
{
void function(Fu f)
{
try
{
f.show();
}
catch (AException e)
{
}
}
}
class Zi extends Fu
{
void show()throws CException
{
}
}
class
{
public static void main(String[] args)
{
Test t = new Test();
t.function(new Zi());
}
}
相关推荐
黑马程序员__移动商城项目实战 包括黑马程序员乐淘商城实战和慕课React+Antd
公式指标，黑马起爆，有助于判断什么时候可以入手
11. 异常处理：学习Hibernate常见的异常，如ConstraintViolationException、ObjectRetrievalFailureException等，以及如何进行相应的错误处理。 12. 实战演练：结合提供的"代码"和"思路图"，通过实际编写和运行代码...
5. **集合框架**：深入学习ArrayList、LinkedList、HashSet、HashMap等常用集合类的内部实现和操作，以及集合的遍历和迭代器。 6. **输入/输出（IO）流**：讲解FileInputStream、FileOutputStream、BufferedReader...
通过阅读和分析这些源码，学习者可以更好地理解Web开发流程，学习如何组织代码结构，以及掌握常见的设计模式和最佳实践。 6. **学习方法** 使用这套源码学习时，建议按照以下步骤： - 阅读源码：理解每个类和方法...
他们将学习Servlet生命周期，以及如何在Servlet中处理GET和POST请求。 2. **JSP**: JSP是Java服务器页面的缩写，用于动态生成HTML。学习者将学习如何在JSP中插入Java代码，创建动态网页，以及如何使用EL...
标题中的“heima_ugo_xiaochengxu_黑马训练营_微信小程序_小程序支付_VantWeapp商城”揭示了这是一个关于微信小程序开发的项目，由黑马训练营提供教学支持，特别关注了商城功能、微信登录和微信支付的集成，并且使用...
预处理包括数据清洗、缺失值处理、异常值检测、特征缩放（如标准化或归一化）以及特征编码（如独热编码）。Pandas库在这一阶段扮演着重要角色，提供了一系列方便的数据操作和分析功能。 然后，笔记会引导读者理解...
在源代码中，你可能会看到如何声明变量、定义方法、控制流程（如if语句、for循环和while循环）、以及异常处理等基本语法。了解这些基础，是构建复杂程序的基石。 二、面向对象编程 Java的核心在于面向对象编程...
本文将基于黑马程序员2016年的培训资料，对Hibernate的核心概念、配置、使用方法以及最佳实践进行深入探讨。 一、Hibernate框架基础 1.1 ORM概述：ORM是Object-Relational Mapping的缩写，它提供了一种将面向对象...
【标题】"传智播客_黑马_品优购_2018"指的是一个由传智播客和黑马程序员联合推出的2018年品优购相关的IT培训课程资源。这个课程可能涵盖了电子商务、互联网产品开发、运营等多个方面，旨在帮助学员掌握最新的技术和...
黑马程序员_张孝祥_Java多线程与并发库,老师讲的非常仔细,老师很有耐心.欢迎大家下载学习.
【青橙电商前台开发02】课程主要涵盖了电商网站前端开发的相关知识，是黑马教育机构推出的borns8e系列课程之一。在这个课程中，你将深入学习如何构建一个功能完善的电商平台前端界面，提升你的前端开发技能。以下是...
总结来说，《黑马程序员_Java基础辅导班教程课件[第01期]第15天》的内容可能涉及了Java语言的核心概念，包括面向对象编程、控制结构、异常处理、文件I/O、集合框架以及内存管理等。通过深入学习和实践这些知识点，...
黑马程序员_毕向东_Java基础视频教程第18天-14-IO流(拷贝文本文件图例).zip
【标题】：“黑马前端学习JS高级md” 【描述】：“黑马JS高级md复习资料” 【标签】：“JS高级”、“JS”、“黑马JS高级” 在前端开发领域，JavaScript（JS）是不可或缺的一部分，特别是在现代Web应用程序中。...
存放黑马项目源代码_heima
5. 实战技巧：如何组织和管理CSS代码，使用预处理器（如Sass、Less等），以及浏览器兼容性问题的处理。 6. 版面设计：包括色彩理论、排版原则、用户体验（UX）和用户界面（UI）设计的基础知识。 这个"品优购"项目...
5. **异常处理**：讲解如何使用try-catch语句块进行错误处理，以及理解不同类型的异常，如IOException、NullPointerException等。 6. **输入/输出流**：解释I/O流的概念，教授如何使用FileReader、FileWriter、...
6. **异常处理**：学习如何使用try-except语句处理程序运行时可能出现的错误。 7. **面向对象编程**：了解类（class）和对象的概念，掌握继承、封装和多态等面向对象特性。 【Python进阶知识】 在学习过程中，你...