（1）
for(System.out.println("a");System.out.println("b");System.out.println("c"))
{
System.out.println("d");
}
错误！System.out.println("b")作为条件无法判断真假
（2）
int x = 1;
for(System.out.println("a");x<3;System.out.println("c"))
{
System.out.println("d");
x++;
}
结果为：a
d
c
d
c
无限循环的最简单表现形式
for(;;){}
while(true){}
break和continue
w:for(int x = 0; x<3;x++)
{
q:for(int y=0;y<4;y++)
{
System.out.println("x="+x);
break w;
}
}
continue只能作用于循环结构,继续循环
for(int x=0;x<3;x++)
{
continue;
System.out.println("x="+x);
}
不会执行System.out.println("x="+x);语句
输出以下图形
*
* *
* * *
* * * *
* * * * *
函数：
可以对功能代码进行封装
当函数运算后，没有具体的返回值时，这时返回值类型用一个特殊的
关键字来表示。该关键字就是void。void：代表的是函数没有具体返回值的情况。
当函数的返回值类型是void时，函数中的return语句可以省略不写。
如何定义一个函数呢？
1、既然函数是一个独立的功能，那么该功能的运算结果是什么先明确
2、在明确在定义该功能的过程中是否需要未知的内容参与运算。
函数重载：
在同一个类中，允许存在一个以上的同名函数，只要
它们的参数个数或参数类型不同即可
什么时候用重载？
当定义的功能相同，但参与运算的未知内容不同，
那么，这时就定义一个函数名称以表示其功能通过参数列表的不同来区分多个同名函数
void show(int a,char b,double c){
}
a.int show(int a,double c,char b){
}重载了，因为参数类型不同。注意：重载和返回值类型没关系
b.double show(int x,char y,double z){}没有，这个函数不可以和给定函数同时存在于同一个类中
数组：
同一种类型数据的集合，其实数组就是一个容器
数组中有一个属性可以直接获取到数组元素个数。
使用方式：数组名称.length
面向对象:
1、理解面向对象
一种思想
面向过程：
强调的是功能行为
面向对象：
将功能封装进对象，强调具备了功能的对象。
面向对象是基于面向过程的。
三个特征：
封装，继承，多态。
成员变量和局部变量
成员变量作用于整个类中
局部变量作用于函数中，或者语句中
在内存中的位置：
成员变量：在堆内存中，因为对象的存在，才在内存中存在。
局部变量：存在栈内存中。
匿名对象使用方式一：当对对象的方法只调用一次时，可以用匿名对象来完成比较简便。
如果对一个对象进行多个成员调用，必须给这个对象起个名字。
匿名对象使用方式二：可以将匿名对象作为实际参数进行传递。
封装:隐藏对象的属性和实现细节，
private:私有，权限修饰符:用于修饰类中的成员
构造函数：
特点：
1、函数名与类名相同。
2、不用定义返回值类型
3、不可以写return语句
对象一建立就会调用与之对应的构造函数。
作用：可以用于给对象进行初始化。
当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数。
构造函数和一般函数在写法上有不同，
在运行上也不同。
构造函数是在对象一建立就运行。给对象初始化。
而一般方法是对象调用才执行。
什么时候定义构造函数呢？
当分析事物时，该事物存在具备一些特性或者行为。
构造代码块是给所有对象进行统一的初始化
构造对象是给对应的对象进行初始化
this到底代表的是什么呢？
this:就代表本类的对象，到底代表哪一个呢？
this代表他所在函数所属对象的引用。
简单说：哪个对象在调用this所在的函数，this就代表哪个对象。
this的应用：当定义类中功能时，该函数内部要调用该函数的对象时，这时用this来表示这个对象。
static:是一个修饰符，用于修饰成员
当成员被静态修饰后，除了可以被对象调用外，还可以直接被类名调用
方法区、共享区、数据区：
static特点：
1、随着类的加载而加载。
也就是说：静态会随着类的消失而消失，说明其生命周期最长。
2、优先于对象存在。
明确一点：静态是先存在。对象是后存在的。
3、被所有对象所共享。
4、可以直接被类名所调用。
实例变量和类变量的区别：
1、存放位置。
类变量随着类的加载而存在于方法区中。
实例变量随着对象的建立而存在于堆内存中。
2、生命周期：
类变量生命周期最长，随着类的消失而消失。
实例变量生命周期随着对象的消失而消失。
静态使用注意事项：
1、静态方法只能访问静态成员。
非静态方法既可以访问静态也可以访问非静态。
2、静态方法中不可以定义this，super关键字。
因为静态优先对象存在，所以静态方法中不可以出现this。
3、主函数是静态的。
静态：
利：对对象的共享数据进行单独空间的存储，节省空间，没有必要每个对象中都
都存储一份。可以直接被类名调用。
弊：生命周期过长，访问出现局限性。（静态虽好，只能访问静态）
主函数：是一个特殊的函数，作为程序的入口，可以被jvm调用。
主函数的定义：
publi：代表着该函数访问权限是最大的。
static：代表主函数随着类的加载就已经存在了。
void：主函数没有具体的返回值。
main：不是关键字，但是是一个特殊的单词，可以被jvm识别。
(String[] arr):函数的参数，参数类型是一个数组，该数组中的元素是字符串。字符串类型的数组。
主函数是固定格式的：jvm识别。
jvm在调用主函数时，传入的是new String[0];
什么时候使用静态：
从两方面下手：
因为静态修饰的内容有成员变量和函数。
什么时候定义静态变量呢？
当对象中出现共享数据时。该数据被静态所修饰。
对象中的特有数据要定义成非静态存在于堆内存中。
什么时候定义静态函数呢？
当功能内部没有访问到非静态数据
那么该功能可以定义成静态的。
静态的应用。
每一个应用程序中都有共性的功能。
可以将这些功能进行抽取，独立封装。
以便复用
静态代码块。
特点：随着类的加载而执行
Person p = new Person("zhangsan",20);
该句话都做了什么事情？
1、因为new用到了person.class，所以会先找到person.class文件并加载到内存中。
2、执行该类中的static代码块，如果有的话，给person.class类进行初始化.
3、在堆内存中开辟空间，分配内存地址。
4、在堆内存中建立对象的特有属性。并进行默认初始化。
5、对属性进行显示初始化。
6、对对象进行构造代码初始化。
7、对对象进行对应的构造函数初始化。
8、将内存地址赋给栈内存p变量。
设计模式：解决某一类问题最行之有效的方法。
java中23中设计模式：
单例设计模式：解决一个类在内存只存在一个对象。
想要保证对象唯一
1、为了避免其他程序过多建立该类对象，先禁止其他程序建立该类对象。
2、还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象。
3、为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。
继承：
1、提高了代码的复用性。
2、让类与类之间产生了关系。有了这个关系，才有了多态的特性。
注意：千万不要为了获取其他类的功能，简化代码而继承。
必须是类与类之间有所属关系才可以继承。
java语言中：java只支持单继承，不继承多继承。
因为多继承容易带来安全隐患。：当多个父类定义了相同功能，当功能内容不同时，子类对象不确定要运行哪一个。
但是java保留了这种机制，并用另一种体现形式来完成表示。多
实现。
java支持多层继承。
如何使用一个继承体系中的功能呢？
想要使用体系，先查阅体系父类的描述，因为父类中定义的是该体系中的共性功能。
那么在具体调用时，要创建
1、变量
如果子类中出现非私有的同名成员变量时。
子类要访问本类中的变量，用this
子类要访问父类中的同名变量，用super
super的使用和this的使用几乎一致
this代表的是本类对象的引用
super代表的是父类对象的引用
当子类沿袭了父类的功能，到子类中，
但子类虽具备该功能，但是功能的内容却和子类不一致。
这时，没有必要定义新功能。
重载：只看同名函数的参数列表。
重写：子父类方法要一模一样。
子父类的构造函数：
在对子类对象进行初始化时，父类的构造函数也会运行，
那是因为子类的构造函数默认第一行有一条隐式的语句super（）。
为什么子类一定要访问父类中的构造函数。
因为父类中的数据子类可以直接获取。所以子类对象在建立时，需要先查看父类如何对这些数据进行初始化的。
所以子类在对象初始化时，要先访问一下父类中的构造函数。
super语句一定定义在构造函数的第一行
子类的所有的构造函数，默认都会访问父类中空参数的构造函数。
因为子类每一个构造函数内的第一行都有一句隐式super（）；
当父类中没有空参数的构造函数时，子类必须手动通过super语句来指定要访问的父类的构造函数
final关键字
final：最终。
作为一个修饰符。
1、可以修饰类、函数、变量。
2、被final修饰的类不可以被继承。
3、被final修饰的方法不可以被复写。
4、被final修饰的变量是一个常量只能赋值一次，既可以修饰成员变量，又可以修饰局部变量。当在描述事物时，一些数据的出现值是固定的，那么这时为了增强阅读性，可以给值起名字，方便阅读。作为常量：常量的书写规范所有字母都大写，如果由多个单词组成，单词间通过下划线连接
5、内部类定义在类中的局部位置上时，只能访问该局部被final修饰的局部变量。
当多个类中出现相同功能，但是功能主体不同，这时可以进行向上抽取。这时，只抽取功能定义，而不抽取功能主体。
抽象类的特点：
1、抽象方法一定在抽象类中。
2、抽象方法和抽象类都必须被abstra关键字修饰。
3、抽象类不可以用new创建对象，因为调用抽象方法没意义。
4、抽象类中的抽象方法要被使用，必须由子类复写起所有的抽象方法后，建立子类对象调用。如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。
抽象类和一般类没有太大的不同。
该如何描述事物，就如何描述事物，只不过该事物中出现了一些看不懂的东西。这些不确定的部分，就是该事物的功能，需要明确出现，但是无法定义主体
抽象类不可以实例化。
。
接口：初期理解，可以认为是一个特殊的抽象类
当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。
接口定义时，格式特点：
1、接口中常见定义：常量，抽象方法。
2、接口中的成员
常量：public static final
方法：public abstract
记住：接口中的成员都是public的。
接口是不可以创建对象的，因为有抽象方法。
需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化
否则子类是一个抽象类。
接口可以被类多实现。也是对多继承不支持的转换形式
接口与接口之间存在多继承
类与类之间只存在单继承
接口的特点
1、接口是对外暴露的规则。
2、接口是程序的功能扩展。
3、接口可以用来多实现。
4、类与接口之间是实现，而且类可以继承
一个类的同时实现多个接口。
5、接口有接口之间可以有继承关系。
多态：可以理解为事物存在的多种体现形态。
1、多态的体现
父类的引用指向了自己的子类对象。
父类的引用也可以接收自己的
2、多态的前提
必须是类与类之间有关系，要么继承，要么实现。
通常还有一应用
5、弊端
但是只能使用父类的引用访问父类的成员
内部类的访问规则：
1、内部类可以直接访问外部类的成员，包括私有。
之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类 的引用
2、外部类要访问内部类，必须建立内部类对象。
访问格式：
当内部类定义在外部内的成员位置上，而且非私有，可以在。。。。
2、当内部类在成员位置上，就可以被成员修饰符所修饰。
比如：private：将内部类在外部类中封装。
static：内部类就具备了静态特征
当内部类被static修饰后，只能直接访问外部类的成员。
在外部其他类中，如何直接访问static内部类呢？
当内部类中定义了静态成员，内部类必须是静态的
当描述事物时，事物的内部还有事物，该事物用内部类来描述。
因为内部事物在使用外部事物的内容。
内部类定义在局部时，
1、不可以被成员修饰符修饰
2、可以直接访问外部类的成员，因为还持有外部类的引用。
但是不可以访问它所在的局部中的变量，只能访问被final修饰的局部变量。
异常：就是程序在运行时出现的不正常情况。
异常由来：问题是现实生活中一个具体的事物，也可以通过java的
类的形式进行描述。并封装成对象。
其实就是jav对不正常情况进行描述后的对象体现。
对于问题的划分：两种：一种是严重的问题，一种非严重的问题。
严重的,java通过error类进行描述。
对于error一般不编写针对性的代码进行处理。
非严重的，java通过exception类进行描述。
无论error或者exception都具有一些共性内容
比如：不正常情况的信息，引发原因等
多异常的处理
1、声明异常时，建议声明更为具体的异常，这样
2、对方声明几个异常，就对应有几个catch块
如果多个catch块中的异常出现继承关系，父类异常catch就放在最下
面。
对于exception可以使用针对性的处理方式进行处理
catch
因为项目中会出现特有的问题，而这些问题并未被java所描述并封装对象。所以对于这些特有的问题可以按照java的对问题封装的思想。
将特有的问题，进行自定义的异常封装。
throws和throw的区别
throws使用在函数上
throw使用在函数内
throws后面跟的异常类，可以跟多个。用逗号隔开
throw后跟的是异常对象
自定义异常时：如果该异常的发生，无法继续进行运算
就让自定义异常继承RuntimeException
对于异常分两种
1、编译时被检测的异常
2、编译时不被检测的异常。
异常：
是对问题的描述，将问题进行对象的封装。
异常体系：
异常体系的特点：异常体系中的所有类以及建立的对象，都具备可抛型。
也就是说可以被throw和throws关键字所操作。
只有异常体系具备这个特点。
throw定义在函数内，用于抛出异常对象。
throws定义在函数上，用于抛出异常类，可以抛出多个用逗号隔开
for(System.out.println("a");System.out.println("b");System.out.println("c"))
{
System.out.println("d");
}
错误！System.out.println("b")作为条件无法判断真假
（2）
int x = 1;
for(System.out.println("a");x<3;System.out.println("c"))
{
System.out.println("d");
x++;
}
结果为：a
d
c
d
c
无限循环的最简单表现形式
for(;;){}
while(true){}
break和continue
w:for(int x = 0; x<3;x++)
{
q:for(int y=0;y<4;y++)
{
System.out.println("x="+x);
break w;
}
}
continue只能作用于循环结构,继续循环
for(int x=0;x<3;x++)
{
continue;
System.out.println("x="+x);
}
不会执行System.out.println("x="+x);语句
输出以下图形
*
* *
* * *
* * * *
* * * * *
函数：
可以对功能代码进行封装
当函数运算后，没有具体的返回值时，这时返回值类型用一个特殊的
关键字来表示。该关键字就是void。void：代表的是函数没有具体返回值的情况。
当函数的返回值类型是void时，函数中的return语句可以省略不写。
如何定义一个函数呢？
1、既然函数是一个独立的功能，那么该功能的运算结果是什么先明确
2、在明确在定义该功能的过程中是否需要未知的内容参与运算。
函数重载：
在同一个类中，允许存在一个以上的同名函数，只要
它们的参数个数或参数类型不同即可
什么时候用重载？
当定义的功能相同，但参与运算的未知内容不同，
那么，这时就定义一个函数名称以表示其功能通过参数列表的不同来区分多个同名函数
void show(int a,char b,double c){
}
a.int show(int a,double c,char b){
}重载了，因为参数类型不同。注意：重载和返回值类型没关系
b.double show(int x,char y,double z){}没有，这个函数不可以和给定函数同时存在于同一个类中
数组：
同一种类型数据的集合，其实数组就是一个容器
数组中有一个属性可以直接获取到数组元素个数。
使用方式：数组名称.length
面向对象:
1、理解面向对象
一种思想
面向过程：
强调的是功能行为
面向对象：
将功能封装进对象，强调具备了功能的对象。
面向对象是基于面向过程的。
三个特征：
封装，继承，多态。
成员变量和局部变量
成员变量作用于整个类中
局部变量作用于函数中，或者语句中
在内存中的位置：
成员变量：在堆内存中，因为对象的存在，才在内存中存在。
局部变量：存在栈内存中。
匿名对象使用方式一：当对对象的方法只调用一次时，可以用匿名对象来完成比较简便。
如果对一个对象进行多个成员调用，必须给这个对象起个名字。
匿名对象使用方式二：可以将匿名对象作为实际参数进行传递。
封装:隐藏对象的属性和实现细节，
private:私有，权限修饰符:用于修饰类中的成员
构造函数：
特点：
1、函数名与类名相同。
2、不用定义返回值类型
3、不可以写return语句
对象一建立就会调用与之对应的构造函数。
作用：可以用于给对象进行初始化。
当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数。
构造函数和一般函数在写法上有不同，
在运行上也不同。
构造函数是在对象一建立就运行。给对象初始化。
而一般方法是对象调用才执行。
什么时候定义构造函数呢？
当分析事物时，该事物存在具备一些特性或者行为。
构造代码块是给所有对象进行统一的初始化
构造对象是给对应的对象进行初始化
this到底代表的是什么呢？
this:就代表本类的对象，到底代表哪一个呢？
this代表他所在函数所属对象的引用。
简单说：哪个对象在调用this所在的函数，this就代表哪个对象。
this的应用：当定义类中功能时，该函数内部要调用该函数的对象时，这时用this来表示这个对象。
static:是一个修饰符，用于修饰成员
当成员被静态修饰后，除了可以被对象调用外，还可以直接被类名调用
方法区、共享区、数据区：
static特点：
1、随着类的加载而加载。
也就是说：静态会随着类的消失而消失，说明其生命周期最长。
2、优先于对象存在。
明确一点：静态是先存在。对象是后存在的。
3、被所有对象所共享。
4、可以直接被类名所调用。
实例变量和类变量的区别：
1、存放位置。
类变量随着类的加载而存在于方法区中。
实例变量随着对象的建立而存在于堆内存中。
2、生命周期：
类变量生命周期最长，随着类的消失而消失。
实例变量生命周期随着对象的消失而消失。
静态使用注意事项：
1、静态方法只能访问静态成员。
非静态方法既可以访问静态也可以访问非静态。
2、静态方法中不可以定义this，super关键字。
因为静态优先对象存在，所以静态方法中不可以出现this。
3、主函数是静态的。
静态：
利：对对象的共享数据进行单独空间的存储，节省空间，没有必要每个对象中都
都存储一份。可以直接被类名调用。
弊：生命周期过长，访问出现局限性。（静态虽好，只能访问静态）
主函数：是一个特殊的函数，作为程序的入口，可以被jvm调用。
主函数的定义：
publi：代表着该函数访问权限是最大的。
static：代表主函数随着类的加载就已经存在了。
void：主函数没有具体的返回值。
main：不是关键字，但是是一个特殊的单词，可以被jvm识别。
(String[] arr):函数的参数，参数类型是一个数组，该数组中的元素是字符串。字符串类型的数组。
主函数是固定格式的：jvm识别。
jvm在调用主函数时，传入的是new String[0];
什么时候使用静态：
从两方面下手：
因为静态修饰的内容有成员变量和函数。
什么时候定义静态变量呢？
当对象中出现共享数据时。该数据被静态所修饰。
对象中的特有数据要定义成非静态存在于堆内存中。
什么时候定义静态函数呢？
当功能内部没有访问到非静态数据
那么该功能可以定义成静态的。
静态的应用。
每一个应用程序中都有共性的功能。
可以将这些功能进行抽取，独立封装。
以便复用
静态代码块。
特点：随着类的加载而执行
Person p = new Person("zhangsan",20);
该句话都做了什么事情？
1、因为new用到了person.class，所以会先找到person.class文件并加载到内存中。
2、执行该类中的static代码块，如果有的话，给person.class类进行初始化.
3、在堆内存中开辟空间，分配内存地址。
4、在堆内存中建立对象的特有属性。并进行默认初始化。
5、对属性进行显示初始化。
6、对对象进行构造代码初始化。
7、对对象进行对应的构造函数初始化。
8、将内存地址赋给栈内存p变量。
设计模式：解决某一类问题最行之有效的方法。
java中23中设计模式：
单例设计模式：解决一个类在内存只存在一个对象。
想要保证对象唯一
1、为了避免其他程序过多建立该类对象，先禁止其他程序建立该类对象。
2、还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象。
3、为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。
继承：
1、提高了代码的复用性。
2、让类与类之间产生了关系。有了这个关系，才有了多态的特性。
注意：千万不要为了获取其他类的功能，简化代码而继承。
必须是类与类之间有所属关系才可以继承。
java语言中：java只支持单继承，不继承多继承。
因为多继承容易带来安全隐患。：当多个父类定义了相同功能，当功能内容不同时，子类对象不确定要运行哪一个。
但是java保留了这种机制，并用另一种体现形式来完成表示。多
实现。
java支持多层继承。
如何使用一个继承体系中的功能呢？
想要使用体系，先查阅体系父类的描述，因为父类中定义的是该体系中的共性功能。
那么在具体调用时，要创建
1、变量
如果子类中出现非私有的同名成员变量时。
子类要访问本类中的变量，用this
子类要访问父类中的同名变量，用super
super的使用和this的使用几乎一致
this代表的是本类对象的引用
super代表的是父类对象的引用
当子类沿袭了父类的功能，到子类中，
但子类虽具备该功能，但是功能的内容却和子类不一致。
这时，没有必要定义新功能。
重载：只看同名函数的参数列表。
重写：子父类方法要一模一样。
子父类的构造函数：
在对子类对象进行初始化时，父类的构造函数也会运行，
那是因为子类的构造函数默认第一行有一条隐式的语句super（）。
为什么子类一定要访问父类中的构造函数。
因为父类中的数据子类可以直接获取。所以子类对象在建立时，需要先查看父类如何对这些数据进行初始化的。
所以子类在对象初始化时，要先访问一下父类中的构造函数。
super语句一定定义在构造函数的第一行
子类的所有的构造函数，默认都会访问父类中空参数的构造函数。
因为子类每一个构造函数内的第一行都有一句隐式super（）；
当父类中没有空参数的构造函数时，子类必须手动通过super语句来指定要访问的父类的构造函数
final关键字
final：最终。
作为一个修饰符。
1、可以修饰类、函数、变量。
2、被final修饰的类不可以被继承。
3、被final修饰的方法不可以被复写。
4、被final修饰的变量是一个常量只能赋值一次，既可以修饰成员变量，又可以修饰局部变量。当在描述事物时，一些数据的出现值是固定的，那么这时为了增强阅读性，可以给值起名字，方便阅读。作为常量：常量的书写规范所有字母都大写，如果由多个单词组成，单词间通过下划线连接
5、内部类定义在类中的局部位置上时，只能访问该局部被final修饰的局部变量。
当多个类中出现相同功能，但是功能主体不同，这时可以进行向上抽取。这时，只抽取功能定义，而不抽取功能主体。
抽象类的特点：
1、抽象方法一定在抽象类中。
2、抽象方法和抽象类都必须被abstra关键字修饰。
3、抽象类不可以用new创建对象，因为调用抽象方法没意义。
4、抽象类中的抽象方法要被使用，必须由子类复写起所有的抽象方法后，建立子类对象调用。如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。
抽象类和一般类没有太大的不同。
该如何描述事物，就如何描述事物，只不过该事物中出现了一些看不懂的东西。这些不确定的部分，就是该事物的功能，需要明确出现，但是无法定义主体
抽象类不可以实例化。
。
接口：初期理解，可以认为是一个特殊的抽象类
当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。
接口定义时，格式特点：
1、接口中常见定义：常量，抽象方法。
2、接口中的成员
常量：public static final
方法：public abstract
记住：接口中的成员都是public的。
接口是不可以创建对象的，因为有抽象方法。
需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化
否则子类是一个抽象类。
接口可以被类多实现。也是对多继承不支持的转换形式
接口与接口之间存在多继承
类与类之间只存在单继承
接口的特点
1、接口是对外暴露的规则。
2、接口是程序的功能扩展。
3、接口可以用来多实现。
4、类与接口之间是实现，而且类可以继承
一个类的同时实现多个接口。
5、接口有接口之间可以有继承关系。
多态：可以理解为事物存在的多种体现形态。
1、多态的体现
父类的引用指向了自己的子类对象。
父类的引用也可以接收自己的
2、多态的前提
必须是类与类之间有关系，要么继承，要么实现。
通常还有一应用
5、弊端
但是只能使用父类的引用访问父类的成员
内部类的访问规则：
1、内部类可以直接访问外部类的成员，包括私有。
之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类 的引用
2、外部类要访问内部类，必须建立内部类对象。
访问格式：
当内部类定义在外部内的成员位置上，而且非私有，可以在。。。。
2、当内部类在成员位置上，就可以被成员修饰符所修饰。
比如：private：将内部类在外部类中封装。
static：内部类就具备了静态特征
当内部类被static修饰后，只能直接访问外部类的成员。
在外部其他类中，如何直接访问static内部类呢？
当内部类中定义了静态成员，内部类必须是静态的
当描述事物时，事物的内部还有事物，该事物用内部类来描述。
因为内部事物在使用外部事物的内容。
内部类定义在局部时，
1、不可以被成员修饰符修饰
2、可以直接访问外部类的成员，因为还持有外部类的引用。
但是不可以访问它所在的局部中的变量，只能访问被final修饰的局部变量。
异常：就是程序在运行时出现的不正常情况。
异常由来：问题是现实生活中一个具体的事物，也可以通过java的
类的形式进行描述。并封装成对象。
其实就是jav对不正常情况进行描述后的对象体现。
对于问题的划分：两种：一种是严重的问题，一种非严重的问题。
严重的,java通过error类进行描述。
对于error一般不编写针对性的代码进行处理。
非严重的，java通过exception类进行描述。
无论error或者exception都具有一些共性内容
比如：不正常情况的信息，引发原因等
多异常的处理
1、声明异常时，建议声明更为具体的异常，这样
2、对方声明几个异常，就对应有几个catch块
如果多个catch块中的异常出现继承关系，父类异常catch就放在最下
面。
对于exception可以使用针对性的处理方式进行处理
catch
因为项目中会出现特有的问题，而这些问题并未被java所描述并封装对象。所以对于这些特有的问题可以按照java的对问题封装的思想。
将特有的问题，进行自定义的异常封装。
throws和throw的区别
throws使用在函数上
throw使用在函数内
throws后面跟的异常类，可以跟多个。用逗号隔开
throw后跟的是异常对象
自定义异常时：如果该异常的发生，无法继续进行运算
就让自定义异常继承RuntimeException
对于异常分两种
1、编译时被检测的异常
2、编译时不被检测的异常。
异常：
是对问题的描述，将问题进行对象的封装。
异常体系：
异常体系的特点：异常体系中的所有类以及建立的对象，都具备可抛型。
也就是说可以被throw和throws关键字所操作。
只有异常体系具备这个特点。
throw定义在函数内，用于抛出异常对象。
throws定义在函数上，用于抛出异常类，可以抛出多个用逗号隔开
218
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
