目录
面向对象
万物皆对象：我们在现实生活中，是通过具体的某个事物归纳总结它们的公共特性，然后产生类。那么类就描述了该种事物的的共性。
对象：在现实生活中存在具体的一个事物。;
类：实际就是对某种类型事物的共性属性与行为的抽取，类是抽象的概念。
人类认识世界： 对象---->类。
在java中： 类 ----->对象。
“面向对象”(Object Oriented,简称OO)是一种以事物为中心的编程思想。
面向对象程序设计（Object-oriented programming，简称：OOP），是一种程序开发的方法。它将对象作为程序的基本单元，将程序和数据封装其中，以提高软件的重用性、灵活性和扩展性。
以“吃饭”为例：
1：面向过程
1：自己动手做
2：买菜
3：洗菜
4：煮饭炒菜
5：很难吃，浪费时间
2：面向对象
1：找专业对象
2：餐馆.点餐
3：餐馆，做饭
4：饭好吃，节约时间，精力
对象（object）代表现实世界中可以明确标识的一个实体。对象有对象的属性（attribute）和对象的行为（behavior）。
对象的行为是由方法定义，调用对象的一个方法，其实就是给对象发消息，要求对象完成一个动作。
面向对象的三大特征
封装(encapsulation)
继承(inheritance)
多态(polymorphism)
开发的过程：其实就是不断的创建对象，使用对象，指挥对象做事情。
设计的过程：其实就是在管理和维护对象之间的关系.
根据对应关系：
属性：类中的成员变量
行为：类中的成员函数
面向对象的计算机语言核心思想： 找适合的对象做适合的事情。
如何找适合的对象：
1. sun已经定义好了很多的类，我们只需要认识这些类，我们就可以通过这些类创建对象使用。
2. 自定义类，通过自定义类来创建对象使用。
自定义类创建对象的三步骤
自定义类
格式：
class 类名{
事物的公共属性使用成员变量描述。
事物的公共行为使用函数描述。
}
通过自定义类创建对象
格式：
类名 变量名 = new 类名();
访问(设置)对象的属性或者调用对象的功能
1.访问对象属性的格式：
对象.属性名.
2.设置对象的属性：
对象.属性名 = 数据。
3. 调用对象的功能
对象.函数名();
封装
封装的三个特性：安全、将变化隔离、可重复。
如果不使用封装，很容易赋值错误，并且任何人都可以更改，造成信息的不安全。
封装的实现：设置类的属性为private(关键字)，不能使用对象名.属性名的方式直接访问对象的属性。
为什么在封装前可以通过对象名.属性名的方式访问？
1：public 成员修饰符，公共的谁都可以访问。
2：private 成员修饰符，私有的，只有在本类中才可以可以访问。
那么如何给封装后的对象属性设置值？
1：对外提供公开的用于设置对象属性的public方法
1：设置set
2：获取get
2：在set方法中加入逻辑判断，过滤掉非法数据。
3：将所有的成员变量封装加上private，提供get、set方法
封装一定要提供get或者set方法吗？
不一定， 根据需求而定的。
在现实开发中一般实体类的所有成员属性（成员变量）都要封装起来。
1：实体类：实体类就是用于描述一类 事物的就称作为实体类。
2：工具类(Arrays数组的工具类):
封装的好处：
1. 提高数据的安全性。
2. 操作简单。
3. 隐藏了实现。
构造函数
构造函数的定义的格式
修饰符 函数名(形式参数){
函数体...
}
构造函数的作用：对对象进行初始化。
1. 构造函数是没有返回值类型的。
2. 构造函数的函数名必须要与类名一致。
3. 构造函数并不是由我们手动调用的，而是在创建对应的对象时，jvm就会主动调用到对应的构造函数。
4. 如果一个类没有显式的写上一个构造方法时，那么java编译器会为该类添加一个无参的构造函数的。
5. 如果一个类已经显式的写上一个构造方法时,那么java编译器则不会再为该类添加一个无参的构造方法。
6. 构造函数是可以在一个类中以函数重载的形式存在多个的。
java编译器添加 的无参构造方法的权限修饰符与类的权限修饰是一致的。
- 一般函数是用于定义对象应该具备的功能。而构造函数定义的是，对象在调用功能之前，在建立时，应该具备的一些内容。也就是对象的初始化内容。
- 构造函数是在对象建立时由jvm调用, 给对象初始化。一般函数是对象建立后，当对象调用该功能时才会执行。
2. 返回值类型的区别：
1. 构造函数是没有返回值类型 的，
2. 普通函数是有返回值类型的，即使函数没有返回值，返回值类型也要写上void。
3. 函数名的区别：
1. 构造函数的函数名必须要与类名一致，
2. 普通函数的函数名只要符合标识符的命名规则即可。
4. 调用方式的区别：
1. 构造函数是 在创建对象的时候由jvm调用的。
2. 普通函数是由我们使用对象调用的，一个对象可以对象多次普通 的函数，
5. 作用上的区别：
1. 构造函数 的作用用于初始化一个对象。
2. 普通函数是用于描述一类事物的公共行为的。
构造代码块
构造代码块的作用：给所有的对象进行统一的初始化。
构造函数的作用： 给对应的对象进行初始化。
构造代码块的格式
{
构造代码块
}
注意： 构造代码块的大括号必须位于成员位置上。
代码块的类别
1. 构造代码块。
2. 局部代码块。大括号位于方法之内。作用：缩短局部变量的生命周期，节省一点点内存。
3. 静态代码块 static
构造代码块要注意的事项
1. java编译器编译一个java源文件的时候，会把成员变量的声明语句提前至一个类的最前端。
2. 成员变量的初始化工作其实都在在构造函数中执行的。
3. 一旦经过java编译器编译后，那么构造代码块的代码块就会被移动构造函数中执行，是在构造函数之前执行的，构造函数的中代码是最后执行的。
4. 成员变量的显示初始化与构造代码块的代码是按照当前代码的顺序执行的。
构造代码块和构造函数的区别：构造代码块是给所有对象进行统一初始化， 构造函数给对应的对象初始化。
构造代码块的作用：它的作用就是将所有构造方法中公共的信息进行抽取。
关键字
this关键字
this关键字代表了所属函数的调用者对象。
this是什么
1：在构造函数中打印this
2：创建对象，打印对象名p
3：this和p是一样的都是内存地址值。
4：this代表所在函数所属对象的引用。
this关键字作用
1. 如果存在同名成员变量与局部变量时，在方法内部默认是访问局部变量的数据，可以通过this关键字指定访问成员变量的数据。
2. 在一个构造函数中可以调用另外一个构造函数初始化对象。
要注意的事项
1. this关键字调用其他的构造函数时，this关键字必须要位于构造函数中的第一个语句。
2. this关键字在构造函数中不能出现相互调用的情况，因为是一个死循环。
Static关键字
1. static修饰成员变量 ：如果有数据需要被共享给所有对象使用时，那么就可以使用static修饰。
静态成员变量的访问方式：
方式1： 可以使用对象进行访问。
格式： 对象.变量名。
方式二： 可以使用类名进行访问。
格式： 类名.变量名;
注意：
1. 非静态的成员变量只能使用对象进行访问，不能使用类名进行访问。
2. 千万不要为了方便访问数据而使用static修饰成员变量，只有成员变量的数据是真正需要被共享的时候才使用static修饰。
static修饰成员变量的应用场景： 如果一个数据需要被所有对象共享使用的时候，这时候即可好实用static修饰
静态函数：
1：静态函数中不能访问非静态成员变量，只能访问静态变量。
2：静态方法不可以定义this,super关键字.
3：因为静态优先于对象存在.静态方法中更不可以出现this
4：非静态函数：非静态函数中可以访问静态成员变量
原因：静态函数是可以使用类名直接调用的，这时候可能还没有存在对象，而非静态的成员数据是随着对象的存在而存在的。
静态的成员变量与非静态的成员变量的区别
1. 作用上的区别：
1. 静态的成员变量的作用共享一个数据给所有的对象使用。
2. 非静态的成员变量的作用是描述一类事物的公共属性。
2. 数量与存储位置上的区别：
1. 静态成员变量是存储方法 区内存中，而且只会存在一份数据。
2. 非静态的成员变量是存储在堆内存中，有n个对象就有n份数据。
3. 生命周期的区别：
1. 静态的成员变量数据是随着类的加载而存在，随着类文件的消失而消失。
2.非静态的成员数据是随着对象的创建而存在，随着 对象被垃圾回收器回收而消失。
静态函数不能访问非静态的成员？
静态函数只要存在有对象，那么也可以访问非静态的数据。只是不能直接访问而已。
static特点
1 随着类的加载而加载，静态会随着类的加载而加载，随着类的消失而消失。说明它的生命周期很长。
2 优先于对象存在。-->静态是先存在，对象是后存在。
3 被所有实例(对象)所共享。
4 可以直接被类名调用
静态变量（类变量）和实例变量的区别
1存放位置
1：类变量随着类的加载而加载存在于方法区中.
2：实例变量随着对象的建立而存在于堆内存中.
2生命周期
1：类变量生命周期最长,随着类的消失而消失.
2：实例变量生命周期随着对象的消失而消失.
单例设计模式
目的
解决一个类在内存中只存在一个对象，想要保证对象的唯一。
1 为了避免其他程序过多的建立该类对象。禁止其他程序建立该类对象。
2 为了其他程序可以访问该类对象，在本类中自定义一个对象。
3 方便其他程序对自定义类的对象的访问，对外提供一些访问方式。
代码
1 将构造函数私有化
2 在类中创建一个私有的本类对象
3 提供一个用类名调用的公有方法获取该对象。
软件行业中23种设计模式
单例设计模式
模板设计模式
装饰者设计模式
观察者设计模式
工厂设计模式
单例设计模式的步骤
饿汉单例设计模式
1. 私有化构造函数。
2. 声明本类的引用类型变量，并且使用该变量指向本类对象。
3. 提供一个公共静态的方法获取本类的对象。
懒汉单例设计模式
1. 私有化构造函数。
2. 声明本类的引用类型变量，但是不要创建对象，
3. 提供公共静态的方法获取本类 的对象，获取之前先判断是否已经创建了本类对象，如果已经创建了，那么直接返回对象即可，如果还没有创建，那么先创建本类的对象，然后再返回。
推荐使用：饿汉单例设计模式。因为懒汉单例设计模式会存在线程安全问题，目前还不能保证一类在内存中只有一个对象。
继承
继承是通过关键字extends体现的。
继承的格式：
class 类名1 extends 类名2{
}
继承要注意的事项
1. 千万不要为了减少重复代码而去继承，只有真正存在着继承关系的时候才去继承。
2. 父类私有的成员不能被继承。
3. 父类的构造函数不能被继承。
4. 创建子类对象时默认会先调用父类无参的构造函数。
继承特点
1：描述类和类之间的关系
2：降低类和类之间的重复代码
3：降低类和类之间的代码重复使用就继承，降低对象和对象之间的代码重复使用静态变量。
继承细节：
1：类名的设定，被继承的类称之为父类(基类)，继承的类称之为子类
2：子类并不能继承父类中所有的成员
super关键字
super关键字代表了父类空间的引用。
super关键字作用
1：主要存在于子类方法中，用于指向子类对象中父类对象。
2：访问父类的属性、函数和构造函数。
3：子父类存在着同名的成员时，在子类中默认是访问子类的成员，可以通过super关键字指定访问父类的成员。
4：创建子类对象时，默认会先调用父类无参的构造方法，可以通过super关键字指定调用父类的构造方法。
this和super区别
this和super很像，this指向的是当前对象的调用，super指向的是当前调用对象的父类。Demo类被加载，执行main方法，Son.class加载，发现有父类Father类，于是Father类也加载进内存。类加载完毕，创建对象，父类的构造方法会被调用（默认自动无参），然后执行子类相应构造创建了一个子类对象，该子类对象还包含了一个父类对象。该父类对象在子类对象内部。this super只能在有对象的前提下使用，不能在静态上下文使用。
1. 代表的事物不一致。
1. super关键字代表的是父类空间的引用。注意：super不是代表父类的一个对象，仅仅是代表空间中的一块内存而已。
2. this关键字代表的是所属函数的调用者对象。
2. 使用前提不一致。
1. super关键字必须要有继承关系才能使用。
2. this关键字不需要存在继承关系也可使用。
3. 调用构造函数的区别：
1. super关键字是调用父类的构造函数。
2. this关键字是调用本类的构造函数。
重写
重写(覆盖 override)的定义
在继承中，子类可以定义和父类相同的名称且参数列表一致的函数，将这种函数称之为函数的重写.
方法重写的前提必须要有继承关系
方法重写的特点
1：当子类重写了父类的函数，那么子类的对象如果调用该函数，一定调用的是重写过后的函数。可以通过super关键字进行父类的重写函数的调用。
2： 继承可以使得子类增强父类的方法
方法重写要注意的事项：
1.方法重写时， 方法名与形参列表必须一致。
2.方法重写时，子类的权限修饰符必须要大于或者等于父类的权限修饰符。
3.方法重写时，子类的返回值类型必须要小于或者 等于父类的返回值类型。
4.方法重写时， 子类抛出的异常类型要小于或者等于父类抛出的异常类型。
子类对象查找属性或方法时的顺序
就近原则，如果子类的对象调用方法，默认先使用this进行查找，如果当前对象没有找到属性或方法，找当前对象中维护的super关键字指向的对象，如果还没有找到编，译报错，找到直接调用。
方法的重载
在一个类中 存在两个或者两个 以上的同名函数,称作为方法重载。
方法重载的要求
1. 函数名要一致。
2. 形参列表不一致（形参的个数或形参 的类型不一致）
3. 与返回值类型无关。
重载和重写的不同
1：重载(overload)：
1：前提：所有的重载函数必须在同一个类中
2：特点：函数名相同，参数列表不同，与其他的无关(访问控制符、返回值类型)
3：不同：个数不同 、 顺序不同、 类型不同
2：重写(override)：
1：前提：继承
2：特点：函数名必须相同、参数列表必须相同；子类的返回值类型要等于或者小于父类的返回值。
final关键字的用法
1. final关键字修饰一个基本类型的变量时，该变量不能重新赋值，第一次的值为最终的。
2. fianl关键字修饰一个引用类型变量时，该变量不能重新指向新的对象。
3. final关键字修饰一个函数的时候，该函数不能被重写。
4. final关键字修饰一个类的时候，该类不能被继承。
抽象类
抽象类的特点
1：有抽象函数的类，该类一定是抽象类。
2：抽象类中不一定要有抽象函数。
3：抽象类不能使用new创建对
4：抽象类主要为了提高代码的复用性，让子类继承来使用。
5：编译器强制子类实现抽象类父类的未实现的方法，可以不实现，前提是子类的也要声明为抽象的。
抽象的优点
1：提高代码复用性
2：强制子类实现父类中没有实现的功能
3：提高代码的扩展性，便于后期的代码维护
抽象类的小疑问
问：抽象类不能创建对象，那么抽象类中是否有构造函数？
答：抽象类中一定有构造函数。主要为了初始化抽象类中的属性。通常由子类实现。
问：final和abstract是否可以同时修饰一个类？
答：一定不能同时修饰。
抽象类注意细节
抽象类可以没有抽象方法（java.awt.*的类就是这样子操作的）。
抽象类可以继承普通类与抽象类。
抽象类不能直接使用类名创建实例，但是有构造方法，构造方法是让子类进行初始化。
抽象类一定有构造方法。
常量的命名规范：全部字母大写，单词与单词之间使用下划线分隔。
abstract与其他修饰符的关系:
final与abstract不能共存:
final:它的作用 修饰类代表不可以继承 修饰方法不可重写
abstract修饰类就是用来被继承的，修饰方法就是用来被重写的。
static static修饰的方法可以用类名调用，
对于abstract修饰的方法没有具体的方法实现，所有不能直接调用，
也就是说不可以与static共存。
private
private修饰的只能在本类中使用，abstract方法是用来被子类进行重写的，有矛盾，所有不能共存。
值传递: 调用一个方法的时候，传递给方法的参数 ，实际上传递变量所存储的值。
接口
接口主要是使用来拓展定义类的功能，可以弥补java中单继承的缺点。
接口的定义格式
interface 接口名{
属性
抽象方法
}
接口的作用
1. 程序的解耦。
2. 定义约束规范。
3. 拓展功能。
接口要注意的事项
1. 接口是一个特殊的类。
2. 接口的成员变量默认的修饰符为： public static final 。那么也就是说接口中的成员变量都是常量，且定义的时候需要赋值。
3. 接口中 的方法都是抽象的方法，默认的修饰符为： public abstract。
4. 接口不能创建对象。
5. 接口是没有构造方法的。
6. 接口是给类去实现使用的，非抽象类实现一个接口的时候，必须要把接口中所有方法全部实现。
7. 有抽象函数的不一定是抽象类，也可以是接口类。
8. 由于接口中的方法默认都是抽象的，所以不能被实例化。
9. 如果实现类中要访问接口中的成员，不能使用super关键字。因为两者之间没有显示的继承关系，况且接口中的成员成员属性是静态的。可以使用接口名直接访问。
实现接口的格式
class 类名 implements 接口名{
}
接口的属性和方法修饰符
- 接口中的所有属性默认的修饰符是 public static final。
- 接口中的所有方法默认的修饰符是 public abstract。
类与接口要注意的事项
1. 非抽象类实现一个接口时，必须要把接口中所有方法全部实现。
2. 抽象类实现一个接口时，可以实现也可以不实现接口中的方法。
3. 一个类可以实现多个接口 。
java不支持多继承，而支持多实现。
多态
对象的多态是指父类的引用类型变量指向了子类的对象或者是接口的引用类型变量指向了接口实现类的对象。
多态要注意的细节
1. 多态情况下，子父类存在同名的成员变量时，访问的是父类的成员变量。
2. 多态情况下，子父类存在同名的非静态的成员函数时，访问的是子类的成员函数。
3. 多态情况下，子父类存在同名的静态的成员函数时，访问的是父类的成员函数。
4. 多态情况下，不能访问子类特有的成员。
多态的应用
1. 多态用于形参类型的时候，可以接收更多类型的数据 。
2. 多态用于返回值类型的时候，可以返回更多类型的数据。
多态的好处： 提高了代码的拓展性。
多态弊端
提高扩展性，但是只能使用父类引用指向父类成员。
总结
多态情况下，子父类存在同名的成员时，访问的都是父类的成员，除了在同名非静态函数时才是访问子类的。
编译看左边，运行不一定看右边。
编译看左边：java编译器在编译的时候，会检查引用类型变量所属的类是否具备指定的成员，如果不具备马上编译报错。
内部类
内部类的概述
将类定义在另一个类的内部则成为内部类。其实就是类定义的位置发生了变化。
在一个类中，定义在类中的叫成员变量，定义在函数中的叫成员函数，那么根据类定义的位置也可以分为成员内部类和局部内部类。
备注：内部类生产的class文件为 “外部类$内部类”，为了标明该内部类是属于具体哪个外部类的。
成员内部类的访问方式
- 内部类可以直接访问外部类的成员属性。(孙悟空相当于内部类飞到牛魔王的肚子里面去)。简单来说就是在外部类提供一个方法创建内部类的对象进行访问。
- 外部类需要访问内部类的成员属性时需要创建内部类的对象。
- 在外部类的成员函数中创建内部类的对象，通过内部类对象对象直接访问内部类的成员。
- 在其他类中直接创建内部类的对象。
格式：外部类.内部类 变量名 = new 外部类().new 内部类();
Outer.Inner inner = new Outer().new Inner();
注意： 如果是一个静态内部类，那么在其他类创建 的格式：
外部类.内部类 变量名 = new 外部类.内部类();
什么时候使用内部类呢？
当我们分析事物时，发现事物的内部还有具体的事物，这时则应该定义内部类了。
内部类的优势：成员内部类作为外部类的成员，那么可以访问外部类的任意成员。
成员内部类访问细节
1. 如果外部类与内部类存在同名的成员变量时，在内部类中默认情况下是访问内部类的成员变量。可以通过"外部类.this.成员变量名" 指定访问外部类的成员。
2. 私有的成员内部类只能在外部类提供一个方法创建内部类的对象进行访问，不能在其他类创建对象了。
3. 成员内部类一旦出现了静态的成员，那么该类也必须 使用static修饰。
私有的成员内部类不能在其他类中直接创建内部类对象来访问。
如果内部类中包含有静态成员，那么java规定内部类必须声明为静态的访问静态内部类的形式：Outer.Inner in = new Outer.Inner();
总结
成员内部类(成员属性、成员方法)特点:
- 私有的成员内部类
特点：不能在其他类中直接创建内部类对象来访问
- 静态的成员内部类
特点：如果内部类中包含有静态成员，那么java规定内部类必须声明为静的
访问静态内部类的形式：
Outer.Inner in = new Outer.Inner();
局部内部类
局部内部类概述：包含在外部类的函数中的内部类称之为局部内部类。
访问：可以在包含局部内部类的方法中直接创建局部内部类的对象调用局部内部类的成员。
注意：局部内部类只能访问所在函数的final属性。即如果局部 内部类访问了一个局部变量，那么该局部变量必须使用final修饰。
匿名内部类
匿名内部类：就是没有类名字的内部类。
匿名内部类作用：简化内部类书写。
匿名内部类的前提:必须继承一个父类或者是实现一个接口。
匿名内部类的格式：
new 父类或者接口(){ 执行代码….};
匿名内部类一般是用于实参。
匿名内部类 ：匿名内部类只是没有类名，其他的一概成员都是具备的。
Animal a = new Animal(){ //多态
//匿名内部的成员
public Animal run(){
System.out.println("狗在跑..");
return this; //this不是代表一个类型而是代表一个对象。
}
}
异常
java异常体系
java的异常体系包含在java.lang这个包默认不需要导入。
|——Throwable （实现类描述java的错误和异常，异常或者错误类的超类。）
|——Error （错误）一般不通过代码去处理。
|——Exceprion （异常）
|——RuntimeException （运行时异常）
|——非运行时异常
错误一般是用于jvm或者是硬件引发的问题，所以我们一般不会通过代码去处理错误的，而异常是需要通过代码去处理的。
Throwable类
- toString() 返回当前异常对象的完整类名+病态信息。
- getMessage() 输出异常的信息，需要通过构造方法传入异常信息（例如病态信息），即返回的是创建Throwable传入的字符串信息。。
- printStackTrace() 打印栈信息。
捕获处理
格式
try{
可能发生异常的代码；
}catch(捕获的异常类型 变量名){
处理异常的代码....
}
捕获处理要注意的细节
1. 如果try块中代码出了异常经过了处理之后，那么try-catch块外面的代码可以正常执行。
2. 如果try块中出了异常的代码，那么在try块中出现异常代码后面的代码是不会执行了。
3. 一个try块后面是可以跟有多个catch块的，也就是一个try块可以捕获多种异常的类型。
4. 一个try块可以捕获多种异常的类型,但是捕获的异常类型必须从小到大进行捕获，否则编译报错。
因为Java虚拟机不允许出现废话，如果上面已经处理过了，那么下面的类型是无法起作用的，就是废话了，因此编译就会报错的。
多个catch语句之间的执行顺序
- 是进行顺序执行，从上到下。
- 如果多个catch 内的异常有子父类关系。
- 子类异常在上，父类在最下。编译通过运行没有问题
- 多个异常要按照子类和父类顺序进行catch
- 父类异常在上，子类在下，编译不通过。(因为父类可以将子类的异常处理，子类的catch处理不到)。
抛出处理
抛出处理要注意的细节
1. 如果一个方法的内部抛出了一个异常对象，那么必须要在方法上声明抛出。
2. 如果调用了一个声明抛出异常的方法，那么调用者必须要处理异常。
3. 如果一个方法内部抛出了一个异常对象，那么throw语句后面的代码都不会再执行了（一个方法遇到了throw关键字，该方法也会马上停止执行的）。
4. 在一种情况下，只能抛出一种类型异常对象。
throw 与throws两个关键字
1. throw关键字是用于方法内部的，throws是用于方法声声明上的。
2. throw关键字是用于方法内部抛出一个异常对象的，throws关键字是用于在方法声明上声明抛出异常类型的。
3. throw关键字后面只能有一个异常对象，throws后面一次可以声明抛出多种类型的 异常。
何时使用抛出处理？何时捕获处理？原则是如何？
如果你需要通知到调用者，你代码出了问题，那么这时候就使用抛出处理.
如果代码是直接与用户打交道遇到了异常千万不要再抛，再抛的话，就给了用户了。这时候就应该使用捕获处理。
运行时异常和非运行时异常
RuntimeException
RunntimeException的子类：
ClassCastException
多态中，可以使用Instanceof 判断，进行规避
ArithmeticException
进行if判断，如果除数为0，进行return
NullPointerException
进行if判断，是否为null
ArrayIndexOutOfBoundsException
使用数组length属性，避免越界
这些异常时可以通过程序员的良好编程习惯进行避免的
1：遇到运行时异常无需进行处理，直接找到出现问题的代码，进行规避。
2：就像人上火一样牙疼一样，找到原因，自行解决即可
3：该种异常编译器不会检查程序员是否处理该异常
4：如果是运行时异常，那么没有必要在函数上进行声
非运行时异常(受检异常)
如果出现了非运行时异常必须进行处理throw或者try{}catch(){}处理，否则编译器报错。
1；IOException 使用要导入包import java.io.IOException;
2：ClassNotFoundException
包的优点
- 防止类文件冲突。
- 使源文件与类文件分离，便于软件最终发布。
注意细节
- 一个java类只能定义在一个包中。
- 包语句肯定是描述类的第一条语句。
包机制引发的问题
有了包之后访问类每次都需要把包名和类名写全。
导包语句的格式：
import 包名.类名; （导入xxx包中某个类）
导包语句要注意的细节：
1. 一个java文件中可以出现多句导包语句。
2. "*"是 导包语句的通配符。可以匹配任何 的类名。
3. import aa.*; 是不会作用于aa包下面的子包的。
推荐使用：import 包名.类名; 因为使用*通配符会导致结构不清晰。
访问修饰符
访问修饰符是用来控制类、属性、方法的可见性的关键字称之为访问修饰符。
- public 一个类中，同一包中，子类中，不同包中
- protected 一个类中，同一包中，子类中
- default 一个类中，同一包中
- private 一个类中
250
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
