3.冒泡排序法（江湖中人尽皆知）

两层循环，外层冒泡轮数，内层一次比较，江湖中人尽皆知。

    /**      * @Author代码贩子、 --南京邮电大学      */     public static void main (String[] args) {         int[] a ={55,4564,22,1,0,56456,41234564,41654321};         //调用完我们自己写的排序方法以后返回一个排序后的数组         int[] test= test(a);         System.out.println(Arrays.toString(test));     }             /*         冒泡排序：         1.比较数组中两个相邻的元素，如果第一个比第二个大就交换这两个数之间的顺序。         2.每一次比较都会产生一个最大的数或者是最小的数。         3.下一轮则可以少一轮排序。         4.一次循环，直到结束。          */             public static int[] test(int[] arrays){                 int temp = 0;                 //外层循环，判断我们要走多少次                 for (int i = 0; i arrays[j]表示如果后一个数大于当前这个数就要进行交换                         if (arrays[j+1]>arrays[j]){                             //需要建立临时变量，进行三变量倒手                             temp = arrays[j];                             arrays[j]= arrays[j+1];                             arrays[j+1]=temp;                             flag = true;                         }                     }                     if (flag=false){                         break;                     }                 }                 return arrays;     }

五：什么是面向对象

“面向对象的方法主要是把事物给对象化，包括其属性和行为。面向对象编程更贴近实际生活的思想。总体来说面向对象的底层还是面向过程，面向过程抽象成类，然后封装，方便使用就是面向对象，（万物皆对象）。

其本质就是：以类的方式组织代码，以对象的组织（封装）数据。

六：类与对象的关系

1.什么是类

什么是类：类是一种抽象的数据类型，他是对某一类事物的整体描述/定义，但是并不代表某一具体的事物。例如：手机，电脑等等；又比如Person类、Pet类、Cat类等等。

2.什么是对象

什么是对象：对象是抽象的具体实例。比如张三是人的一个具体实例，旺财是一个狗的具体实例。

                      能够体现出特点，展现出功能的具体实例，而不是一个抽象的概念。

3.创建与初始化对象

1.什么是类

      1.使用new关键字创建对象，除了分配内存空间以外还会个创建好的对象进行默认初始化以及对类中的构造器进行调用。

      2.通常情况下一个类能不能直接使用，需要根据一个类创建一个对象，才能使用，因此我们需要创建一个对象来调用这个类。

创建类的步骤
1）导包：
      格式：import包名称.类名称;
      对于同一个包的情况下，可以省略导包语句
2）创建：
      格式：
      类名称 对象名=new 类名称（）;
3）使用：
      （1）成员属性：
      格式： 对象名.成员变量名；、
      （2）成员方法：
      格式: 对象名.成员方法名（参数）;

定义一个标准类（包括如下四个部分）
（1） 所有的成员变量都用private修饰、
（2） 每个成员变量都有getxxx()detxxx()方法
（3） 有一个无参构造
（4） 有一个全参构造

    /**      * @Author代码贩子、 --南京邮电大学      */     //一个项目只存在一个main方法     public static void main(String[] args) {         /*类：抽象的、需要实例化           类实例化后会返回一个自己的对象           students对象就是Students的一个具体实例         */         Students students= new Students();         students.name = "张三";         students.age=20;         System.out.println(students.name+students.age);     }     //属性     String name;     int age;      //方法     void stu(){         //this代表这个类  指向型         System.out.println(this.name+"学生在学习");     }

2.什么是构造器

类中的构造器也叫构造方法，在进行创建对象的时候必须进行调用。并且每一个类中都隐藏一个无参构造。

格式：public 类名称（形参 实参）{
方法体
}

构造器：

      1.和类名必须相同

      2.没有返回值

作用：

      1.new的本质就是在调用构造方法

      2.初始化对象的值

注意点：

      定义有参构造之后，如果还想用无参构造的话，那么就必须显示的定义一个无参构造。

    /**      * @Author代码贩子、 --南京邮电大学      */     //一个项目只存在一个main方法     public static void main(String[] args) {         Students students= new Students("代码贩子");         System.out.println(students.name);     }     String name;     //一个类及时什么也不写也会存在一个方法     //定义一个构造器     //实例化初始值     /*     使用new关键字，必须使用构造器     用来初始化值      */     //无参构造     public Students(){         //代表的是上面的name         this.name = "张三";     }     //有参构造     //一旦定义了有参构造，无参构造必须显示定义     public Students(String name){         this.name = name;     } //alt+inset可以快速构造

3.创建对象内存分析

      1.首先先在方法区把Demo01类的游戏额代码信息放进来。

      2.主方法main（）会被压入栈.。

      3.一旦new会在方法区加载出Student这个类。

      4.当等于通过Students A= new Students();生成一个A同学放入栈中（此时的A只是一个引用或者变量名）。

      5.针对于这个对象A会在堆里面，通过这个模板new了一个A。

      6.此时的action（）方法其实调用了方法区中的action（）方法，此时Students A= new Students();方法就完成了。

      7.接下来给name、age进行赋值。

      8.将方法区的Demo01中的常量池中的值丢个堆中A进行name和age的赋值，此时A.name = "代码贩子、"; A.age = 24;以及A.action();中的值就赋完了，此时这个对象A的堆中就有这些值了，此时就可以使用它了。

      9.如果出现了同学B就相当于当等于通过Students A= new Students();生成一个A同学放入栈中（此时的A只是一个引用或者变量名）。

      10.针对于这个对象A会在堆里面，通过这个模板new了一个B。

      11.此时的action（）方法其实调用了方法区中的action（）方法，此时Students。 B= new Students();方法就完成了，此时后面的操作相同。

注意：静态方法区所有带static关键字的东西一开始就在这个地方，和类一起加载的，类一加加载，它就加载了。所有的对象都可以加载它。

    /**      * @Author代码贩子、 --南京邮电大学      */     //一个项目只存在一个main方法     public static void main(String[] args) {         Students A= new Students();         A.name = "代码贩子、";         A.age = 24;         System.out.println(A.name+A.age+A);         A.action();     }     public String name;     public int age;     //无参构造     void action(){         System.out.println("疯狂学习Java编程知识！");     }

 七：封装、继承、多态

1.封装

定义（自己理解）：该露的露，该藏的藏。将一些较为复杂的内部结构进行隐藏，将一些简单的（比如接口）该暴露给用户的东西暴露出来，比如电视机的外观等等。大部分程序的细节都应该藏起来。我们设计的程序应该追求”高内聚，低耦合“（也就是系统内部的数据操作应该由自己完成，不允许外部进行干预；仅仅暴露少量的方法给外部来进行使用）。

一旦使用了private进行修饰，本类当中可以随意访问，但是超出了本类就不可以访问了。
间接访问private成员变量，就定义一对getxxx（）setxxx（）方法

对于set来说，不能有返回值，参数类型和成员变量对应
对于get来说，不能有参数，必须有返回值类型，并且返回值类型与成员变量对应。

封装的意义：

      1.提高程序的安全性，保护数据。

      2.隐藏代码的关键细节（以s1.setAge(24)来说，用户根本不知道里面干了什么，只有我们程序员才知道）;。

      3.统一接口。

      4.提高了系统的可维护性。

    /**      * @Author代码贩子、 --南京邮电大学      */         public static void main(String[] args) {         Students s1 = new Students();         /*         s1.name;无法进行调用，变量被private被私有了         如果换成public公有的关键字才可以被调用          */         s1.setName("代码贩子、");         s1.setAge(24);         s1.setSex('男');         System.out.println(s1.getName());         System.out.println(s1.getAge());         System.out.println(s1.getSex());     }     //private关键字为私有化     private String name;//名字     private int age;//年龄     private char sex;//性别     /*     想要解决主程序中的s1.name被调用的问题就需要提供一些可以操作这个属性的方法     解决办法就是提供一些public的get、set方法      */     //获得这个数据     public String getName(){         return this.name;     }     //给这个数据设置值     public void  setName(String name){          this.name=name;     }     //快捷键      public int getAge() {         return age;     }      public void setAge(int age) {         if (age<100&&age>0) {             this.age = age;         }else {             this.age=3;         }     }      public char getSex() {         return sex;     }      public void setSex(char sex) {         this.sex = sex;     }

2.继承

定义：继承的本质就是对某一批类进行的抽象，从而实现对现实世界最好的建模。

关键字：extends。意思为”扩展“，子类是父类的扩展。

修饰符的级别;public>protected>default（或者是不写）>private

Java中的类只有单继承的关系，没有双继承的关系（相当于一个父类可以有多个子类，但是多个子类只能以有一个父类）。

继承是类和类之间的一种关系，除此之外，类和类之间的关系还有依赖、组合、聚合等。

继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，用关键字extends来表示。

子类和父类之间，从意义上讲应该具有”is a“的关系。

public class Demo01 {     /**      * @Author代码贩子、 --南京邮电大学      */     public static void main(String[] args) {         Student student =new Student();         //子类可以继承父类的所有方法         /*         父亲说我有钱了         儿子继承了父亲的财产         儿子也说我有钱了          */         //子类没有任何的说明         //接收这个方法         student.money();         //子类可以继承父类的所有属性         //父类中父亲姓代码，那么子类中的儿子也会继承叫代码         System.out.println("我跟随父亲的姓氏姓："+student.xingshi);         /*         父类中的父亲有十个小妾，但是用private关键字进行私有了，只属于父类自己         儿子不管是出于道德还是出于代码逻辑都不能进行继承         System.out.println(student.xiaoqie);         因此子类无法进行继承和调用          */         /*         出于道德不继承父亲的小妾，但是父亲有十件古董，但是被父亲私有制了，那么我们要想获得必须经过父亲的同意         让父类提供一些public的get、set方法          */         System.out.println("父亲同意将私有的古董给我："+student.getGudong()+"件");     } } public class Demo01 {     /**      * @Author代码贩子、 --南京邮电大学      */     public static void main(String[] args) {         Student student =new Student();         //子类可以继承父类的所有方法         /*         父亲说我有钱了         儿子继承了父亲的财产         儿子也说我有钱了          */         //子类没有任何的说明         //接收这个方法         student.money();         //子类可以继承父类的所有属性         //父类中父亲姓代码，那么子类中的儿子也会继承叫代码         System.out.println("我跟随父亲的姓氏姓："+student.xingshi);         /*         父类中的父亲有十个小妾，但是用private关键字进行私有了，只属于父类自己         儿子不管是出于道德还是出于代码逻辑都不能进行继承         System.out.println(student.xiaoqie);         因此子类无法进行继承和调用          */         /*         出于道德不继承父亲的小妾，但是父亲有十件古董，但是被父亲私有制了，那么我们要想获得必须经过父亲的同意         让父类提供一些public的get、set方法          */         System.out.println("父亲同意将私有的古董给我："+student.getGudong()+"件");     } } //学生（派生类；Person的子类）继承了人的所有关系 public class Student extends Person { } //教师（派生类；Person的子类）继承了人的所有关系 public class Teacher extends Person { }  

3.this和super关键字

supper代表队的是在子类中调用父类中的属性或者是方法。

public class Demo01 {     /**      * @Author代码贩子、 --南京邮电大学      */     public static void main(String[] args) {         Student student = new Student();         student.name("代码贩子本人");     } } /**  * @Author代码贩子、 --南京邮电大学  */ public class Person extends Object {     protected String name = "代码贩子、"; } public class Student extends Person {     private String name = "小代码贩子、";     void name(String name){         System.out.println(name);//代表的是方法传进来的String name         System.out.println(this.name);//代表的是private私有制的name         System.out.println(super.name);//代表的是父类protected受保护的name     } }

public class Demo01 {     /**      * @Author代码贩子、 --南京邮电大学      */     public static void main(String[] args) {         Student student = new Student();     } }  /**  * @Author代码贩子、 --南京邮电大学  */ public class Person extends Object {    public void say(){         System.out.println("我是父亲");     } } public class Student extends Person {     public void say(){         System.out.println("xusheng");     }     public void test(){         say();         this.say();         super.say();     } } 

如果父类的构造器换成私有制的关键字属性，那么原本的子类就无法使用super关键字来进行方法的调用。

这里参杂了一个代码位置的问题。

首先在我们的子类以及父类都会隐藏一个默认的无参构造器。相当于在Person类中有个public Person() { System.out.println("父类无参执行了！"); }，在子类中有个public Student() { System.out.println("子类有参执行了！"); }。此时在new Studengt（）；的时候执行的结果如下所示：

因为在子类中调用子类的构造器之前还隐藏了一段代码： super()。

super();的代码只能放在子类构造器第一行，如果和System.out.println("子类有参执行了！");互换位置就会报错。因为new Studengt（）；的同时将父类的也new了。

this关键字也是如此，急啊如在子类中急啊如一个有参构造器，public Student(String name) { this.name = name; }，此时调用的时候this("代码贩子、");也只能放在无参构造器的额第一行。此时苏果想要放super关键字也必须放第一行，this关键字就会报错。

public class Demo01 {     /**      * @Author代码贩子、 --南京邮电大学      */     public static void main(String[] args) {         Student student = new Student();     } }  /**  * @Author代码贩子、 --南京邮电大学  */ public class Person extends Object {     //走一个无参构造器     public Person() {         System.out.println("父类无参执行了！");     }     void say(){         System.out.println("我是父亲");     } } public class Student extends Person {     private  String name;      public void say(){         System.out.println("xusheng");     }     public Student() {         /*         在调用构造器的时候，要么调用父类要么调用子类，必须保证在构造器的第一个         正常情况下super();不写也是正常的，会默认的调用无参。          */         this("代码贩子、");//调用本类有参构造器，必须放在子类的第一行。         //super();//调用父类无参构造器，必须放在子类的第一行。（隐藏）         System.out.println("子类有参执行了！");     }     public Student(String name) {         this.name = name;     }      public void test(){         say();         this.say();     } }

假如父类中的无参构造我们不写，只写了有参构造，那么在子类中就无法进行父类无参构造的调用，不仅如此，子类中的无参也会报错。南无说我就想要调用父类中的有参构造，那么就需要在子类无参构造中利用super("代码贩子、");的形式一步步的调用。

public class Demo01 {     /**      * @Author代码贩子、 --南京邮电大学      */     public static void main(String[] args) {         Student student = new Student();     } }  /**  * @Author代码贩子、 --南京邮电大学  */ public class Person extends Object {     public String name;     //走一个有参构造器      public Person(String name) {         this.name = name;     }      void say(){         System.out.println("我是父亲");     } } public class Student extends Person {     private  String name;      public void say(){         System.out.println("xusheng");     }     public Student(){         super("代码贩子、");     }      public void test(){         say();         this.say();     } } 

因此我们封装的时候无论一个类怎么写，在写的时候一般只要重写了有参构造，一般都会加上无参构造。

super注意点：

      1.super是调用父类的构造方法，必须写在构造方法的第一个。

      2.super必须只能出现在子类的方法或者3.构造方法中。

      3.this和super不能同时调用构造方法。

 VS this注意点：

      1.代表的是本身调用者这个对象。

      2.代表父类对象的应用。

前提：

      2.没有继承的前提下也可以使用。

      3.只能在继承条件下才可以使用。

构造方法：

      this（）；调用的是本类的构造。

      super（）；调用的是父类的构造。

4.方法重写

 静态方法：

public class Demo01 {     /**      * @Author代码贩子、 --南京邮电大学      */     public static void main(String[] args) {         /*         方法的调用只和定义的数据类型有关           */         A a = new A();         a.test();//走的是A类的静态方法          B b = new A();//父类的引用可以指向子类         b.test();//走的是B类的静态方法     } } //A类继承了B类 public class A extends B {     public static void test(){         System.out.println("A=>test()");     } } //重写都是方法的重写，和属性无关 public class B {     public static void test(){         System.out.println("B=>test()");     } } 

 非静态方法：

此时把A和B中的静态方法去掉，利用快捷键在A类中进行重写，默认走的都是B的方法。如果在A类中重写自己的方法，得到的都是A的方法。所以可以得出一个结论，就是静态方法和非静态方法有区别。

原因是B b = new A();//非静态方法中子类重写了父类的方法。此时才叫重写

并且重写的时候修饰符还必须是public的，不能是私有的。

只有子类继承了父类才能重写，并且是子类重写父类的方法。

public class A extends B {     @Override     public void test() {         super.test();     } } //重写都是方法的重写，和属性无关 public class B {     public  void test(){         System.out.println("B=>test()");     } } 

public class A extends B {     @Override     public void test() {         System.out.println("A=>test()");     } } //重写都是方法的重写，和属性无关 public class B {     public  void test(){         System.out.println("B=>test()");     } } 

 总结（重写）：

      1.必须有继承到关系并且还是子类重写父类的方法，和属性无关。

特点：

      1.方法名必须相同。

      2.参数列表必须相同。

      3.修饰符范围可以扩大。

      4.抛出的异常：可以被缩小但是不能扩大。

      总结：子类的方法和父类必须要一致，方法体不同。

为什么需要重写？

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

5.多态

定义：同一个方法可以根据发送对象的不同而采用多种不同的行为方式。一个对象的实际类型是确定的，但可以指向对象的引用类型很多。

多态可以让程序变得更灵活。

一个对象的实际类型是确定的，比如new Student()，new Person();但是可以指向这个类型的引用类可以是任意的。比如：Person s2 = new Student(); Object s3 = new Student()。

public class Demo01 {     /**      * @Author代码贩子、 --南京邮电大学      */     public static void main(String[] args) {         /*         一个对象的实际引用类型是确定的，比如：         new Student()         new Person()          */         Student s1 = new Student();//子类指向的引用         /*         子类能调用的方法都是自己的或者是父类的          */         //父类的引用可以指向子类（有父子关系就可以 ，比如用String肯定不行，因为没有指定的关系。）         Person s2 = new Student();//父类指向的引用         /*         父类型虽然可以指向子类，但是不能调用子类独有的方法          */         Object s3 = new Student();          s2.run();//运行结果为run，因为子类重写了父类的方法，执行的为子类的方法         s1.run();         s1.eat();         //对象能执行哪些方法，主要看对象左边的类型，和右边的关系不大。         /*         ((Student)s2).eat();         强制转换后可以进行调用          */         (s2.eat());//无法调用是因为 Person s2 = new Student();虽然new了Student()但不能使用Student()方法，要看Person里面有没有，有的话才能用。         // 子类重写了父类的方法，执行的为子类的方法。子类和父类的方法都有的话，子类没有重写方法，就调用父类的，如果重写的话就带哦用子类的。     } }  /**  * @Author代码贩子、 --南京邮电大学  */ public class Person extends Object {     public void run(){         System.out.println("run");     } } public class Student extends Person{     @Override     public void run() {         System.out.println("son");     }     public void eat(){         System.out.println("eat");     } } 

注意事项：

      1.首先多态是方法的多态，跟属性无关。

      2.要有关系（父子类），不然的话会出现类型转换异常。

存在条件：

      1.要有继承的关系。

      2.方法需要重写（static属于类，不属于实例、final输入常量，在常量池，private私有的不能重写就不能进行多态）。（假如子父类都有run方法，那么子类没有重写方法，就调用父类的，如果重写的话就带哦用子类的）。

      3.父类引用指向子类对象、

6.instanceof关键字

作用：instanceof关键字可以判断两个类之间是否存在父子关系。

      1.父类引用指向子类的对象。

      2.子类转换为父类（向上转型），不用强制转换。

      3.父类转换为子类（向下转型），强制转换后会丢失方法。

      4.方便方法的调用，减少重复的代码，提升代码的利用率并且使代码变得更简洁。

public class Demo01 {     /**      * @Author代码贩子、 --南京邮电大学      */     public static void main(String[] args) {         //Object>String         //Object>Person>Student         //Object>Person>Teacher         //System.out.println(A instanceof B);         //A和B是否有继承关系         Object object = new Student();         System.out.println(object instanceof Student);//true         System.out.println(object instanceof Person);//true         System.out.println(object instanceof Object);//true         System.out.println(object instanceof Teacher);//false         System.out.println(object instanceof String);//false         Person person = new Student();         System.out.println(person instanceof Student);//true         System.out.println(person instanceof Person);//true         System.out.println(person instanceof Object);//true         System.out.println(person instanceof Teacher);//false         //System.out.println(person instanceof String);//编译错误     } }  /**  * @Author代码贩子、 --南京邮电大学  */ public class Person extends Object {     public void run(){         System.out.println("run");     } } public class Student extends Person{     @Override     public void run() {         System.out.println("son");     }     public void eat(){         System.out.println("eat");     } } 

public class Demo01 {     /**      * @Author代码贩子、 --南京邮电大学      */     public static void main(String[] args) {         Person student = new Student();         //因为这里是Person类型的student         //student.eat();         //将Person类型的student的对象转换成student类型，我们就可以使用student类型的方法了。        Student obj = (Student) student;        //这样就可以使用低一层的方法了        obj.eat();        //第二种写法（（student）obj）.eat();         /*         由低转高（子类转换成父类）         可能会丢失一些方法          */         Person person = new Student();         //丢失一些方法         //person.eat();     } }  /**  * @Author代码贩子、 --南京邮电大学  */ public class Person extends Object {     public void run(){         System.out.println("run");     } } public class Student extends Person{     @Override     public void run() {         System.out.println("son");     }     public void eat(){         System.out.println("eat");     } } 

7.static关键字

      1.static静态变量在类中是共享的。

      2.非静态方法可以访问本类中的所有静态方法。

      3.静态方法可以调用本类中所有的静态方法。

原因：因为静态的方法是和mian方法一起加载出来的，加载之前还没有普通的方法，所以就无法调用。

public class Demo01 {     /**      * @Author代码贩子、 --南京邮电大学      */     /*     static静态变量在类中是共享的      */     private static int name;//静态变量     private double age;//非静态变量     public static void main(String[] args) {         System.out.println(name);//直接可以调用         System.out.println(age);//不可以直接调用        Demo01 demo01 = new Demo01();         //通过对象调用         System.out.println(demo01.age);         System.out.println(demo01.name);     } } 

      1.静态代码块(最早的执行)；静态代码块只在一开始执行一次并且后面将不再执行。

      2.匿名代码块在对象一创建的时候，就先走匿名代码块，然后再走构造器；作用：赋初始值。

      3.构造器最后执行。

public class Demo01 {     /**      * @Author代码贩子、 --南京邮电大学      */     {         //匿名代码块         //作用：赋初始值         System.out.println("匿名代码块");     }     static {         //静态代码块(最早的执行)         System.out.println("静态代码块");     }      public Demo01(){     //构造器（最后执行）         System.out.println("构造器");     }     public static void main(String[] args) {         Demo01 demo01 = new Demo01();         System.out.println("-------------分隔符-------------");         /*         因为静态代码块只执行一次         对象一创建的时候，就先走匿名代码块，然后再走构造器         静态代码块只在一开始执行一次并且后面将不再执行          */         Demo01 demo02 = new Demo01();//此时执行的时候静态代码块就没了     } } 

 8.抽象类

抽象类定义;在普通类的结构里面增加抽象方法的组成部分。

抽象方法定义：是指没有方法体的方法。

关键字为：abstract。

注意：

      1.不能new这个抽象类，只能靠它的子类进行实现。

      2.抽象类中可以写普通的方法。

      3.抽象方法必须在抽象类中。

 /**  * @Author代码贩子、 --南京邮电大学  */ //抽象类 public abstract class Person {     //约束 有人帮我们实现      //只有方法的名字，没有方法的实现     public abstract void work(); } //抽象类的所有方法，继承了它的子类，都必须要实现它的方法，除非子类本身也是一个抽象类。 public class Student extends Person{     @Override     public void work() {      } } 

9.接口

接口的定义：简单来说为某种特征的约定。

关键字：interface。

      1.类可以实现接口 implements

      2.实现了接口的类，就需要重写接口中的方法

      3.利用接口实现多继承，但是与继承关系无关。

//接口定义的关键字interface //接口都需要有实现类 public interface userService {     //接口中的所有定义都是抽象的 public abstract     void add(String name);     void delete(String name);     void update(String name);     void query(String name); } public interface timeService {     void timer(); } //类可以实现接口 implements //实现了接口的类，就需要重写接口中的方法 //利用接口实现多继承 public class userServiceImpl implements userService,timeService{     @Override     public void add(String name) {      }      @Override     public void delete(String name) {      }      @Override     public void update(String name) {      }      @Override     public void query(String name) {      }      @Override     public void timer() {      } } 

总结：

      1.约束。

      2.定义一些方法，让不同的人实现功能。

      3.接口不能被实例化，并且接口没有构造方法。

      4.implements关键字可以实现多个接口。

      5.必须要重写接口中的方法。

10.内部类

定义：将一个类定义在一个类或者一个方法里面，这样的类称着内部类。

注意：一个Java文件中可以有多个class类，但是只能有一个public class类。

1.成员内部类

定义：成员内部类是最普通的一种内部类，成员内部类可以访问外部类所有的属性和方法。但是外部类要访问成员内部类的属性和方法，必须要先实例化成员内部类。

public class Demo01 {     /**      * @Author代码贩子、 --南京邮电大学      */     public static void main(String[] args) {         A a = new A();         a.out();         //通过这个外部类来实例化内部类         A.Inner inner = a.new Inner();         inner.in();         inner.getoutId();     } } public class A {     private int id = 10;     public void out(){         System.out.println("这是一个外部类");     }     public class Inner{         public void in(){             System.out.println("这是一个内部类");         }         //内部类可以获得外部类的私有属性以及方法         public void getoutId(){             System.out.println(id);         }     } } 

2.静态内部类

定义：静态内部类就是在成员内部类多加了一个 static 关键字。静态内部类只能访问外部类的静态成员变量和方法（包括私有静态）

import A.Inner;  public class Demo01 {     /**      * @Author代码贩子、 --南京邮电大学      */     public static void main(String[] args) {         A a = new A();         a.out();         //通过这个外部类来实例化内部类        Inner inner = new Inner();        inner.getoutId(); //        A.Inner inner = a.new Inner(); //        inner.in(); //        inner.getoutId();     } } public class A {     private static int id = 10;     public void out(){         System.out.println("这是一个外部类");     }     public static class Inner{         public void in(){             System.out.println("这是一个内部类");         }         //内部类可以获得外部类的私有属性以及方法         public void getoutId(){             //静态内部类此时无法获得id，原因可以参考内存的解释 之后外部类的属性变量也是静态的才可以加载id             System.out.println(id);         }     } } 

3.匿名内部类

定义：顾名思义就是没有名字的类。

public class Demo01 {     /**      * @Author代码贩子、 --南京邮电大学      */     public static void main(String[] args) {         //没有名字初始化的类，不用将实例保存在变量中         new B().eat();        UseService useService = new UseService() {             @Override             public void Hello() {              }         };     }  } class B{     public void eat(){         System.out.println("干饭!");     } } interface UseService{     void Hello(); }

4.局部内部类

定义：局部内部类就是定义在代码块内的一个内部类。

局部内部类的作用范围仅仅就在它所在的代码块里。局部内部类不能被public ，protected，private以及static修饰，但是可以被final修饰。

/**  * @Author代码贩子、 --南京邮电大学  */ public class A {     public void method(){         class Inner{             public void in(){                              }         }     } } 

11.异常

定义：在程序运行过程中出现的错误，称为异常。异常就是程序运行过程中出现了不正常现象导致程序的中断。在Java中，把各种异常现象进行了抽象形成了异常类。

分类：检查时异常；运行时异常；错误。

          检查时异常：检查时异常最具有代表性的就是用户错误或者是问题引起的异常，这种异常是我们程序员无法进行预测的。例如我们要打开一个文件时文件不见了，这些异常都是在编译时不能被简单的忽略的。

          运行时异常：运行时异常是可能被程序员避免的异常，与检查时异常相反，运行时异常可以在编译时被忽略。

          错误：错误不是异常，而是不被程序员控制的问题，错误在代码中通常被忽略。例如当栈溢出时，错误就产生了，并且在程序编译的时候也无法被找到。

部分异常体系结构如下图所示：

1.抛出以及捕获异常

关键字：try、catch、final、throw、throws。

      try：抛出异常（尝试着去处理什么东西）。

      catch：捕获异常。

      final：无论有什么异常发生，finally都会被执行（可以运行清理类型等收尾善后性质的语句）。

      throw：当程序发生异常而无法处理的时候，会抛出对应的异常对象。

      throws：throws用来在类中捕获异常信息，标明方法可能抛出的异常。

public class Demo01 {     /**      * @Author代码贩子、 --南京邮电大学      */     public static void main(String[] args) {         int a = 1;         int b = 0;         try {//监控区域             System.out.println(a/b);         }catch (ArithmeticException e){             System.out.println("程序出现异常，变量b不能为0");         }finally {//finally一般用来处理善后工作             System.out.println("finally");         }     } } 

注意：

      1.程序的最后可以不要finally 。IO流以及资源需要关闭通常放在finally里面。

      2.捕获异常可以catch多个，但是要把作用域最小的放在上面。

      3.快捷方式：选中要捕获异常的代码 ctrl+t选择异常类即可。

public class Demo01 {     /**      * @Author代码贩子、 --南京邮电大学      */     public static void main(String[] args) {         int a = 1;         int b = 0;         try {//监控区域            Demo01 demo01 = new Demo01();             //System.out.println(a/b);             demo01.a();         }catch (Exception e){//catch里面存放的是想要捕获的异常类型             System.out.println("程序出现异常，变量b不能为0");         }catch (Throwable t){             System.out.println("异常");         }finally {//finally一般用来处理善后工作             System.out.println("finally");         }     }     public void a(){         b();     }     public void b(){         a();     } } 

 我们也可以用throw来主动抛出异常。

public class Demo01 {     /**      * @Author代码贩子、 --南京邮电大学      */     public static void main(String[] args) {         int a = 1;         int b = 0;         try {             new Demo01().text(1,0);         }catch (ArithmeticException e){             e.printStackTrace();         }     }     //假如这个方法中，处理不了这个异常，方法上抛出异常,在调用闪光也要进行捕获     public void text(int a, int b) throws ArithmeticException{         if (b == 0) {//主动抛出异常 throw 一般用在方法中             throw new ArithmeticException();         }         System.out.println(a/b);     } }

2.自定义异常

定义：使用Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户还可以自定义异常，用户自定义异常类，只需要继承Exception类即可。

在程序中使用自定义异常类，大体可以分为以下步骤。

      1.创建自定义常类。

      2.在方法中通过throw关键字抛出异常。

      3.如果在当前抛出异常的方法中处理异常，可以使用try——catch语句来捕获异常并处理，否则在方法的声明处通过throws关键字指明要抛出给方法调用的异常，继续下一步操作。

      4.在出现异常方法的调用者中捕获并处理异常。

public class Text {     static void Test(int a) throws Demo01 {         if(a>10){             throw new Demo01(a);//抛出         }else{             System.out.println("传递的参数为："+a);         }     }      public static void main(String[] args) {         try {             Test(1);         }catch (Demo01 e){             System.out.println("Demo01"+e);         }     } } //继承Except异常类 public class Demo01 extends Exception{     /**      * @Author代码贩子、 --南京邮电大学      */         //传递数字        private int detial;      public Demo01(int a) {         this.detial = a;     }     //异常的打印信息     @Override     public String toString() {         return "Demo01{" +                 "detial=" + detial +                 '}';     } } 

总结：

      1.处理运行时异常时，采用逻辑法合理规避同时辅助try——catch处理。

      2.在多重catch快后面，可以加一个catch（Exception）来处理可能会被遗漏的异常。

      3.对于不确定的代码，也可以加上try——catch，处理潜在的异常。

      4.尽量去处理异常，切忌只是简单的调用printStackTrace（）去打印输出。

      5.具体如何处理异常，要根据不同的业务需求和异常类的类型去决定。

      6.尽量添加finally语句块去释放占用的资源。