文章目录

一、初始面向对象
- 什么是面向对象？
二、方法回顾和加深
三、对象的创建分析
- 类与对象的关系
- 创建与初始化对象
- 内存分析
四、面向对象三大特性☆
- 封装
- 继承
- - object类
  - super & this
  - 方法重写
- 多态 ★
- - instanceof和类型转换
- static关键字详解
五、抽象类和接口
- 抽象
- 接口 ☆
六、内部类
七、异常
- 什么是异常
- 异常体系结构
- - Error错误
  - Exception异常
- Java异常处理机制和处理异常
- 自定义异常
- 总结

一、初始面向对象

面向过程&面向对象
面向过程思想：

步骤清晰简单，第一步做什么，第二部做什么…
面向过程适合处理一些较为简单的问题。

面向对象思想：

物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
面向对象适合处理复杂的问题，适合处理需要多人协作的问题！

对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。

什么是面向对象？

面向对象编程（Object-Oriented Programming, OOP）的本质：以类的方式组织代码，以对象的形式组织(封装)数据。
核心思想：抽象
三大特性：
- 封装
- 继承
- 多态
从认识论的角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象。
从代码运行角度考虑是先有类后有对象。类是对象的模板。

二、方法回顾和加深

方法的定义

修饰符
返回类型

//Demo01类
public class Demo01 {//main方法public static void main(String[] args) {}/*修饰符 返回值类型 方法名（...）｛//方法体return 返回值；｝*/public String sayHellp(){return "hello,world";}public int max(int a ,int b ){return a>b ? a : b ;//三元运算符！}
}

break （跳出switch，结束循环）和 return （结束方法，返回一个结果）的区别
方法名（注意规范，见名知意）
参数列表（参数类型，参数名）…
异常抛出

方法的调用：递归

静态方法
非静态方法

     /*静态方法 static调用：类名+方法名  Student.say();public static void say(){System.out.println("say...");}*//*非静态方法1.实例化这个类 new+类名+.方法名  new Student().say();2.对象类型  对象名  =   对象值;Student student = new Student();调用：类名+.方法名public void say(){System.out.println("say...");}*/public static void main(String[] args) {//非静态方法Student student = new Student();student.say();}//static静态方法是和类一起加载，在创建对象的时候就已经有了//所有a不可以调用bpublic static void a(){//b();//报错}//类实例化后才存在public  void b(){a();//可以调a}

形参和实参
值传递和引用传递

public class Demo03 {public static void main(String[] args) {//值传递int a=1;System.out.println(a);//1Demo03.change(a);System.out.println(a);//1//引用传递Perosn perosn = new Perosn();System.out.println(perosn.name);//nullDemo03.change1(perosn);System.out.println(perosn.name);//法师}//值传递  返回值为空!!!public static void change(int a){a=10;}//引用传递：传递对象，本质还是值传递public static void change1(Perosn perosn){//perosn 是一个对象：指向的是 ---> Perosn perosn = new Perosn();//这是一个具体的人，可以改变属性perosn.name = "法师";//它赋值的是}
}
class Perosn {String name;//null
}

this关键字（代表当前这个类或对象）

三、对象的创建分析

类与对象的关系

类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物。
- 动物、植物、手机、电脑…
- Person类、Pet类、Car类等，这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为。
对象是抽象概念的具体实例。
- 张三就是人的一个具体实例，张三家里的旺财就是狗的一个具体实例。
- 能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念。

创建与初始化对象

使用new来创建对象。
使用new关键字创建的时候，除了分配内存之外，还会给创建好的对象进行默认的初始化，以及对类中构造器的调用。

    public static void main(String[] args) {//类是抽象的，必须要用new来实例化//类实例化后会返回一个自己的对象！//Student对象就是一个Student类的具体实例！Student student = new Student();student.name="fashi";System.out.println(student.name);//fashi}

类中的构造器也被称为构造方法，是在进行创建对象的时候必须要调用的。有以下特点：
- 必须和类的名字相同。
- 没有返回类型，也不能写void。

public class Student {//一个类即使什么都不写，也会存在一个默认的无参构造方法//属性：字段String name;int age;//无参构造// 作用：//1.使用new关键字，本质是在调用构造器//2.可以用来实例化初始化对象的值 this.age=12;public Student(){} //无参构造//有参构造//一旦定义了有参构造，无参就必须显示定义public Student(String name){this.name=name;}//Alt+insert 快捷键 构造方法//方法public void say(){System.out.println(this.name+"say...");}/* 总结：1.类与对象类是一个模板、抽象的；对象是一个具体的实例。2.方法定义与调用！3.对应的引用引用类型基本类型（8）对象是通过引用来操作的：栈—>堆（地址）4.属性：字段Field 成员变量默认初始化: 数字: 0 0.0 char : u0000 boolean : false 引用类型: null修饰符 属性类型 属性名 = 属性值！5.对象的创建和使用- 必须使用 new 关键字创造对象，构造器 Person fashi= new person();- 对象的属性 fashi.name- 对象的方法 fashi.sleep();6.类:静态的属性 属性动态的行为 方法类里只能写这两个。*/
}

内存分析

public class Pet {public String name; //默认 nullpublic int age;   //默认 0//默认存在无参构造public void shout(){System.out.println("叫了一声。。。");}
}public class Demo02 {public static void main(String[] args) {Pet dog = new Pet();dog.name = "旺财";dog.age = 3;dog.shout();Pet cat= new Pet();cat.name = "猫猫";cat.age = 4;cat.shout();}
}

四、面向对象三大特性☆

封装

该露的露，该藏的藏
- 我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据细节由自己完成，不允许外部干涉； 低耦合：仅暴露少量的方法给外部使用。
封装（数据的隐藏）
- 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
属性私有：private， get / set ;

public class Student {//private: 属性私有private String name;//名字private int age;//学号private char sex;//性别//提供一些可以操作这个属性的方法//提供一些public 的 get/set 方法//get 获得这个数据  String name = s1.getName();public String getName(){return this.name;}//set 给这个数据设置值 s1.setName("法师");public void setName(String name){this.name = name;}//快捷键 alt + insert
}

封装的意义：
- 提高程序的安全性，保护数据。
- 隐藏代码的实现细节。
- 统一接口。
- 系统的可维护性增加了。

继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
extends 的意思是“扩展”。子类是父类的扩展。
Java 中类只有单继承，没有多继承！一个儿子只能有一个爸爸，但是一个爸爸可以有多个儿子。
继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。
继承关系的俩个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends 来表示。
子类和父类之间，从意义上讲应该具有“is a”的关系。

 //学生(子类)  继承 人(父类)public class Student extends Person{ /*Person extends Object*/...}//老师(子类)  继承 人(父类)public class Teacher extends Person{ /*Person extends Object*/...}//子类继承了父类，就会拥有父类的全部方法，但private私有属性及方法无法被继承。//public //公共的//protected //受保护的//default //默认的//private //私有的，无法被继承//ctrl+h 继承树 可以查看类关系

object类

在Java中，所有类，都默认直接或间接继承Object类 。
被final修饰的类，无法被继承（断子绝孙）。

super & this

super注意点：

super 调用父类的构造方法，必须在构造方法的第一个行。
super 必须只能出现在子类的方法或者构造方法中!
super 和 this 不能同时调用构造方法！

super与this的区别：

代表的对象不同：
- this：本身调用者这个对象
- super：代表父类对象的应用
前提：
- this：没有继承也可以使用
- super：只能在继承条件才可以使用
构造方法：
- this()：本类的构造
- super()：父类的构造

//学生(子类)  继承 人(父类)
public class Student extends Person{ /*Person extends Object*/private String name="heizi";public Student() {//隐藏代码： 默认调用了父类的无参构造 super();//super();//必须放在子类构造器代码第一行System.out.println("Student无参执行了");}public void test(String name){System.out.println(name);//形式参数，传递的值System.out.println(this.name);//heizi 当前类的nameSystem.out.println(super.name);//fashi  父类的name}public void print(){System.out.println("Student");}public void test1(){print();//当前类的this.print();//当前类的super.print();//父类的}
}

public class Person {protected  String name="fashi";public Person() {System.out.println("Person无参执行了");}public void print(){System.out.println("Person");}
}

public class Application {public static void main(String[] args) {//this 调用当前类，super 调用父类Student student = new Student();/*Person无参执行了Student无参执行了*/student.test("QQ");/*QQheizifashi*/student.test1();/*StudentStudentPerson*/}
}

方法重写

重写：子类的方法必须与父类方法必须一致，方法体不同。
重写是方法的重写，与属性无关。
重写方法只与非静态方法有关，与静态方法无关（静态方法不能被重写）。

 public class B {public void test(){ System.out.println("B==>test()");}}//继承public class A extends B{ @Override //注解：重写了B的方法public void test(){System.out.println("A==>test()");}}public class Application {public static void main(String[] args) {//方法的调用只和左边定义的类型有关A a = new A();a.test(); //A==>test()//父类的引用指向了子类，但静态方法没有被重写B b = new A();b.test(); //静态方法：B==>test()   非静态方法：A==>test()//静态方法和非静态方法的区别很大！！！//静态方法：方法的调用只和左边定义的类型有关//非静态方法：重写//静态方法是类的方法，非静态方法是对象的方法//有static时，b调用了B类的方法，因为b是b类定义的//没有static时，子类重写了父类的方法，b调用的是对象的方法，而b是A类new出来的对象，调用A的方法}}

重写：重写只和非静态方法有关，静态没用，只能 Public 。需要有继承关系，子类重写父类的方法！

方法名必须相同
参数列表必须相同
修饰符：范围可以扩大，但不能缩小；public > protected > Default > private
抛出的异常：范围，可以被缩小但不能扩大；ClassNotFoundException <— Exception(大)

重写，子类的方法和父类必须要一致，但方法体不同！

为什么需要从写：

父类的功能，子类不一定需要，或者不一定满足！

快捷键：Alt + Insert override;

静态的方法和非静态的方法区别很大！！！

多态 ★

可以实现动态编译：类型，提高可扩展性。
即同一方法可以根据发送对象的不同而采用不同的行为方式。
一个对象的实际类型是确定的，但可以指向对象的引用可以有很多。

多态存在条件：

有继承关系
子类重写父类方法
父类引用指向子类对象

 public class Person {public void run(){System.out.println("run...");}}public class Student extends Person{@Overridepublic void run() {System.out.println("son...");}public void eat(){System.out.println("son eat...");}}public class Application {public static void main(String[] args) {//一个对象的实际类型是确定的//new Student();   new Person();//可指向的引用类型不确定，父类的引用指向子类Student s1 = new Student();//子类能调用的方法都是自己的或继承父类的Person s2 = new Student();//父类可以指向子类，但是不能调用子类独有的方法Object s3 = new Student();//父类有，子类没有，子类继承父类的全部方法  输出run...//但是子类重写父类方法后，执行子类的方法  输入son...s2.run();s1.run();//子类重写后，执行子类方法  输入son...s1.eat();//eat()是子类的独有方法((Student) s2).eat();//父类不能调用子类独有方法，会被强制转换为子类//对象能执行哪些方法，主要看对象左边的类型，和右边的关系不大！！！}}

多态的注意事项：

多态是方法的多态，属性没有多态性。
父类和子类，有联系才能进行转换，不然会出现类型转换异常：ClassCastException
存在条件：存在继承关系，方法需要重写，父类引用指向子类对象！Father f1 = new Son();

不能重写的方法：

static 方法，属于类，它不属于实例。
final 常量，被final修饰的无法修改，属于常量池。
private 私有方法，不能被重写。

instanceof和类型转换

instanceof 判断一个对象是什么类型。（引用类型之间的转换）

        //System.out.println（x instanceof y）; ：true or false （能不能编译通过，看x所指向的实际类型是不是y的子类型）//实际上是看是x和y否有继承关系，且x所指向的实际类型是否是y类型//若x所指向的实际类型和y类型有关系，也会通过//两边有关系才可以进行比较，否则会编译错误//Object>String//Object>Person>Teacher//Object>Person>StudentObject object = new Student();//Student指向Object类型System.out.println(object instanceof Student);//trueSystem.out.println(object instanceof Person);//trueSystem.out.println(object instanceof Object);//trueSystem.out.println(object instanceof Teacher);//falseSystem.out.println(object instanceof String);//falseSystem.out.println("===================================");Person person = new Student();System.out.println(person instanceof Student);//trueSystem.out.println(person instanceof Person);//trueSystem.out.println(person instanceof Object);//trueSystem.out.println(person instanceof Teacher);//false//System.out.println(person instanceof String);//编译错误（同一级）System.out.println("===================================");Student student = new Student();System.out.println(student instanceof Student);//trueSystem.out.println(student instanceof Person);//trueSystem.out.println(student instanceof Object);//true//System.out.println(student instanceof Teacher);//编译错误//System.out.println(student instanceof String);//编译错误//类型之间的转化：父-子（高-低）//高转低要强制转换//高               低Person obj = new Student(); //只能用Person方法//obj.go();//编译报错((Student)obj).go(); //强转之后就可以用Student方法//低转高默认就进行转换了//子类转换为父类，可能会丢失一些自己的方法！！//Student student= new Student();//Person person=student;

总计：

父类引用指向子类的对象。
把子类转换为父类，向上转型，但会丢失自己原来的一些方法。
把父类转换为子类，向下转型，需要强制转换，才能调用子类方法。
方便方法的调用(转型)，减少重复的代码。

static关键字详解

//static
public class Student  {//属性private static int age;//静态的变量，可以被类中共享，多线程比较常用!private double score;//非静态变量//方法public void run(){//因为静态方法在类生成的时候就已经存在！！！//非静态方法可以直接访问类中的静态方法//Student.go();}public static void go(){//静态方法可以调用静态方法的，但不能调用类中的非静态方法}{//创建对象的时候自动就创建了，在构造器之前  2//代码块（匿名代码块）可以赋初始值System.out.println("匿名代码块");}static {//在类一加载时就已经执行，而且只加载一次  1//静态代码块System.out.println("静态代码块");}public Student() {//3System.out.println("构造方法");}public static void main(String[] args) {//属性Student s1 = new Student();System.out.println(s1.age);//通过方法可以正常调用System.out.println(s1.score);//通过方法可以正常调用System.out.println(Student.age);//静态变量，可以直接用类名进行调用//System.out.println(Student.score);//非静态变量不可以这样使用//方法Student.go();//静态方法不需要new,可以直接调用,直接写 go(); 也可以//Student.run(); //非静态方法需要new出来new Student().run();//代码块System.out.println("----------------------");Student s2 = new Student();//静态代码块//匿名代码块//构造方法//第二次执行static不在执行//匿名代码块//构造方法}
}

//静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;public class Application {public static void main(String[] args) {//第一种随机数，不用导包System.out.println(Math.random()); //0.011540144065683489//第二种随机数，静态导入包System.out.println(random()); //0.40652961470940285System.out.println(PI);//3.141592653589793}
}

final修饰的类不能被继承!!!

五、抽象类和接口

抽象

abstract 修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法；如果修饰类，那么该类就是抽象类。
抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类。
抽象类，不能使用 new 关键字来创建对象，它是用来让子类继承的。
抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的。
子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法；否则该子类也要声明为抽象类，然后由子子类实现抽象方法。

  //abstract 抽象类public abstract class Action {//约束~有人帮我们实现//abstract，抽象方法，只有方法名字，没有方法的实现！public abstract void doSomething();}//抽象类的所有方法，若继承了它的子类，都必须要实现它的所有方法//除非子类也是抽象方法，那就由子子类实现public class A extends Action {@Overridepublic void doSomething() {}}

注意：

不能 new 这个抽象类，只能靠子类去实现它；它只是一个约束。
抽象类中可以写普通方法，但抽象方法必须在抽象类中。
抽象的抽象，new会报错“Missing method body, or declare abstract”

思考题：
抽象类存在构造器吗?
抽象类存在的意义？

接口 ☆

普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）都有！
接口：只有规范！没有方法的实现，自己无法写方法，专业的约束！约束和实现分离：面向接口编程~
接口就是规范，定义的是一组规则，体现了现实世界中“如果你是…则必须能…”的思想。“如果你是天使，则必须能飞。如果你是汽车，则必须能跑。”
接口的本质是契约，就像我们人间的法律一样，制定好后大家都遵守。
OO的精髓，是对对象的抽象，最能体现这一点的就是接口，为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如c++、java、c#等），就是因为设计模式所研究的，实际上就是如何合理的去抽象。
声明类的关键字是class，声明接口的关键字是interface

// 接口定义的关键字；interface 接口都需要实现类!
public interface UserService {// public void ss(){ } //报错；接口内不能写方法//接口中的所有定义其实都是抽象的，默认被public abstract修饰public abstract void run();void add(String name);void delete(String name);//接口还可以定义变量，所有定义的属性都是静态的常量public static final int AGE = 99;int ABC = 99;
}

public interface TimeService {void time();
}

//类可以实现多个接口  implements 接口
//实现接口的类，必须要实现接口的全部方法
//利用接口实现多继承
public class UserServiceImpl implements UserService,TimeService {@Overridepublic void run() {}@Overridepublic void add(String name) {}@Overridepublic void delete(String name) {}@Overridepublic void time() {}
}

接口作用总结：

接口是约束，规范
接口定义一些的方法，可以让不同的人实现，多个人完成共同的工作。
接口中所有默认的方法public abstract，所有常量默认public static final
接口不能被实例化，因为接口中没有构造方法。
implements 可以实现多个接口。实现接口的类，必须要实现（重写）接口的全部方法

六、内部类

内部类就是在一个类的内部在定义一个类，比如A类中定义一个B类，那么B累相对A类来说就称为内部类，而A类相对B类来说就是外部类了。

特点：

编译之后可生成独立的字节码文件。
内部类可直接访问外部类私有成员，而不破坏封装。
可为外部类提供必要的内部功能组件。

 //身体 Body.classclass Body{ //头部class Header{//内部类也会生成class文件  Body$Header.class}}

注：一个java类中可以有多个class类型，但是只能有一个public class。

成员内部类：可以获得外部类的私有属性和私有方法。

在类的内部定义，与实例变量、实例方法同级别的类。
内部类是作为外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象。 Outer.Inner inner = outer.new Inner();
当外部类、内部类存在重名属性时，会优先访问内部类属性。
成员内部类里不能定义静态成员、可以包含静态常量(final)。

public class Outer {//外部类//实例变量private int id = 10;private int age = 20;public void out(){System.out.println("这是外部类的方法");}//内部类public class Inner{private int id = 20;private String name = "李四";public void in(){System.out.println("这是内部类的方法");}//内部类可以获得外部类的私有属性和私有方法public void getID(){//打印外部类属性，内部类属性和外部类属性重名  Outer.thisSystem.out.println(Outer.this.id);System.out.println(age);//Outer.this.age//打印内部类中的属性System.out.println(id);//this.idSystem.out.println(name);}}
}

    public static void main(String[] args) {//外部类通过 new 获取Outer outer = new Outer();//内部类通过外部类来实例化//外部类 . new 内部类Outer.Inner inner = outer.new Inner();//Inner inner=new Outer().new Inner();inner.in();//这是内部类的方法inner.getID();//10 20 20 李四}

静态内部类：不能访问外部类私有属性和私有方法。

不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员。
只有静态内部类，才可以用static修饰。

public class Outer {//外部类//实例变量private int id = 10;public void out(){System.out.println("这是外部类的方法");}//静态内部类，级别和外部类相同，可以直接创建public static class Inner{private int age= 10;//静态成员private static int count = 1000;public void in(){System.out.println("这是内部类的方法");//调用外部类的属性//1. 先创建外部类对象Outer outer = new Outer();//2. 调用外部类对象的属性System.out.println(outer.id);//调用静态内部类的属性和方法System.out.println(age);//调用静态内部类的静态属性System.out.println(Inner.count);}}
}// 测试类
public class Test{public static void main(String[] args) {//直接创建静态内部类对象  new Outer.Inner() 表示包含关系，并不是创建对象Outer.Inner inner = new Outer.Inner();inner.in();}
}

局部内部类：在外部类的方法里定义的类。

定义在外部类方法中，作用范围和创建对象范围仅限于当前方法。
局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为final。
限制类的使用范围：只能在当前方法中使用。

//外部类
public class Outer{//实例变量private String name = "刘德华";private int age = 35;//方法public void show(){//定义局部变量：不能带访问修饰符//若局部变量不是常量，该变量在show()方法执行完后就会消失//但Inner内部类属于方法，并不会消失；new Inner()内部类对象在堆中并不会立即消失//所以类和对象并不能直接引用已经消失的变量 因此需要加上finalString address = "深圳";//局部内部类：注意不能加任何访问修饰符 和局部变量级别相同class Inner{//局部内部类属性private String phone = "11111";private String email = "lll@qq.com";//成员内部类里不能定义静态成员、可以包含静态常量(final)//private final static String email = "lll@qq.com";public void show2(){//可以直接访问外部类的属性//如果局部内部类为静态的，访问外部类的属性需要先实例化一个对象System.out.println(name); // 相当于Outer.this.nameSystem.out.println(age);//访问内部类的属性System.out.println(phone);//this.phoneSystem.out.println(this.email);//访问局部变量 在jdk1.7要求必须常量final、但在jdk1.8之后会自动添加finalSystem.out.println(address);//实际运行编译时，address已经变成实际的值了//System.out.println("深圳");}}//创建局部内部类对象！！！才能使用Inner inner = new Inner();inner.show2();}
}//测试类
public class Test{public static void main(String[] args) {//创建外部类对象Outer outer = new Outer(); outer.show();}
}

匿名内部类：没有名字去初始化类，不用将实例保存到变量中。

没有类名的局部内部类（一切特征都与局部内部类相同）。
必须继承一个父类或者实现一个接口。
定义类、实现类、创建对象的语法合并，只能创建一个该类的对象。
优点：减少代码量。
缺点：可读性较差。

public class Test {public static void main(String[] args) {//匿名内部类new Apple().eat();new UserService(){@Overridepublic void hello() {System.out.println("hello..");}};}
}
class Apple{public void eat(){System.out.println("eat..");}
}
interface UserService{void hello();
}

七、异常

什么是异常

实际工作中，遇到的情况不可能是非常完美的。比如：你写的某个模块，用户输入不一定符合你的要求；你的程序要打开某个文件，这个文件可能不存在或者文件格式不对；你要读取数据库的数据，数据可能是空的等；我们的程序再跑着，内存或硬盘可能满了。等等。
软件程序在运行过程中，非常可能遇到刚刚提到的这些异常问题，我们叫异常，英文是：Exception，意思就是例外。这些，例外情况，或者叫异常，怎么让我们写的程序做出合理的处理，而不至于程序崩溃。
异常指程序运行中出现不期而至的各种状况，如：文件找不到，网络连接失败，非法参数等。
异常发现在程序运行期间，它影响了正常的程序执行流程。

简单分类：

检查性异常：最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如：打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。
运行时异常：运行时异常是可能被程序员去避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。
错误 ERROR：错误不是异常，而是脱离程序员控制的问题，错误在代码中通常被忽略，编译时不容易被发现。例如：当栈溢出时，一个错误就发生了，它们在编译也检查不到的。

异常体系结构

Java 把异常当做对象来处理，并定义一个基类 java.lang.Throwable 作为所有异常的超类。
在 Java API 中已经定义了许多异常类，这些异常类分为两大类，错误Error和异常Exception 。

Error错误

Error 类对象有 Java 虚拟机生成并抛出，大多数错误与代码编写者所执行的操作无关。
Java 虚拟机运行错误（Virtual MachineError），当 JVM 不再有继续执行操作所需的内存资源时，将出现 OutOfMemoryError。这些异常发生时， Java 虚拟机（JVM）一般会选择线程终止。
还有发生在虚拟机试图执行应用时，如类定义错误（NoClassDefFoundError）、链接错误（LinkageError）。这些错误是不可查的，因为它们在应用程序的控制和处理能力之外，而且绝大多数是程序运行时不允许出现的情况。

Exception异常

在 Exception 分支中有一个重要的子类 RuntimeException （运行时异常）
- ArrayIndexOutOfBoundsException（数组下标越界）
- NullPointerException（空指针异常）
- ArithmeticException（算术异常）
- MissingResourceException（丢失资源）
- ClassNotFoundException（找不到类）等异常，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。
一些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发现；
Error 和 Exception 的区别：Error 通常是灾难性的致命错误，是程序无法控制和处理的，当出现这些异常时，Java 虚拟机（JVM）一般会选择终止线程；Exception 通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这类异常。

Java异常处理机制和处理异常

抛出异常
捕获异常
异常处理五个关键字：try、catch、finally、throw、throws

可以当出现异常时，捕获它，防止程序停止。

try、catch、finally和throw：

    public static void main(String[] args) {int a = 1;int b = 0;//假设要捕获多个异常：要从小到大的写！不然会报错，提示大异常以及覆盖小异常//Ctrl+Alt+T 快捷键插入 try-catchtry { //try监控区域//throw 抛出异常一般在方法中使用if(b==0){ throw new ArithmeticException(); //主动抛出异常}System.out.println(a/b);}//catch (ArithmeticException e){ //catch 捕获异常//   System.out.println("程序出现异常，变量b不能为0");//}catch (Error e) {   //catch（想要捕获的异常类型！）捕获异常System.out.println("Error");}catch (Exception e){ //catch（想要捕获的异常类型！）捕获异常//e.printStackTrace();//打印错误的栈信息System.out.println("Exception");}catch (Throwable t){//最高级，放在最后面System.out.println("Throwable");}finally { //一定会执行，用于处理善后工作，如关闭资源//可以不用加finally，但try和catch必须要写System.out.println("finally");}}

throws：

    //假设这个方法中，处理不了这个异常。在方法上抛出异常throws，由上一级捕获。public void test(int a,int b)throws ArithmeticException{if (b == 0) {throw new ArithmeticException();//throw 主动的抛出异常,一般在方法内}System.out.println(a / b);}public static void main(String[] args) {int a = 1;int b = 0;try{new Test().test(1,0);}catch(ArithmeticException e){e.printStackTrace();}}

自定义异常

使用 Java 内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户还可以自定义异常。用户自定义异常类，只需继承 Exception 类即可。
在程序中使用自定义异常类，大体可分为以下几个步骤：
- 创建自定义异常类。
- 在方法中通过 throw 关键字抛出异常对象。
- 如果在当前抛出异常的方法中处理异常，可以使用 try-catch 语句捕获并处理；否则在方法的声明处通过 throws 关键字指明要抛出给方法调用者的异常，继续进行下一步操作。
- 在出现异常方法的调用者中捕获并处理异常。

//自定义异常
public class MyException extends Exception{//传递数字>10就为异常private int detail;//创建一个提示信息public MyException(int a) {this.detail=a;}//toString打印信息：异常的打印信息@Overridepublic String toString() {return "MyException{" +"detail=" + detail +'}';}
}

public class Test1 {//创建一个可能会存在异常的方法static void test(int a) throws MyException {System.out.println("传递的参数为："+a);if (a>10){throw new MyException(a);//抛出}System.out.println("ok");}public static void main(String[] args) {try { //捕获异常test(11);} catch (MyException e) {// if( ){ }       可以增加一些处理异常的代码块System.out.println("MyException =>"+e);//传递的参数为：11//MyException =>MyException{detail=11}}}
}

总结

处理运行时异常，采用逻辑去合理规避同时辅助 try-catch 处理
在多重 catch 块后面，可以加一个 catch（Exception）来处理可能被遗漏的异常
对于不确定的代码，也可以加上 try-catch ，处理潜在的异常
尽量去处理异常，切忌只是简单地调用 printStackTrace()去打印输出
具体如何处理异常，要根据不同的业务需求和异常类型去决定
尽量添加 finally 语句块去释放占用的资源

Java基础学习(6)---Java面向对象相关推荐

java基础学习：java中的反射
一.什么是java反射什么是 java 的反射? 说到反射,写这篇文章时,我突然想到了人的"反省",反省是什么?吾一日三省吾身,一般就是反思自身,今天做了哪些对或错的事情. ja ...
Java基础学习(11)---Java注解和反射
文章目录一.注解概述二.内置注解三.元注解四.自定义注解五.反射概述 ★ 静态语言 VS 动态语言反射机制 Java反射机制研究及应用 Java反射优点和缺点六.Class类获取Cla ...
Java基础学习(2)---Java基础语法
文章目录一.注释.标识符.关键字 1.注释 2.标识符 3.关键字二.数据类型 1.强类型语言和弱类型语言 2.Java的数据类型三.类型转换四.变量.常量 1.变量 2.常量五.运算符算 ...
java基础学习笔记（面向对象编程）
Dog类 package zlb.day06.demo01; public class Dog {//狗的属性:名字和年龄.String name;int age;//狗的行为:可以跑.可以叫.pub ...
传智黑马java基础学习——day09（面向对象、及封装）
右键点击图片,可另存为.
【Java基础学习】Java基础中容易忽略点-2
- 多线程高可用.高性能.高并发 - 概念方法间的调用:普通方法的调用,从哪来到哪里去,闭合的一条路径多线程使用:开辟多条路径程序.进程和线程程序指的是静态的代码:进程指的是操作系统调用程序 ...
Java基础学习总结——Java对象的序列化和反序列化
一.序列化和反序列化的概念把对象转换为字节序列的过程称为对象的序列化. 把字节序列恢复为对象的过程称为对象的反序列化. 对象的序列化主要有两种用途: 1) 把对象的字节序列永久地保存到硬盘上,通常存 ...
java基础学习篇——java学习目录与应用场景
两个方向--大数据开发.javaEE 技术拓展: 数据结构,常用算法,常用设计模式,JVM JAVAEE之路 javase--javaweb--javaee框架 (spring.springmvc.s ...
Java基础学习汇总
Java基础学习汇总 java语言基础 java函数和数组 java面向对象 java异常整理用,早就停更... 写作不易,如果您觉得写的不错,欢迎给博主点赞.收藏.评论.收藏来一波~让博主更有动力 ...

Java基础学习(6)---Java面向对象