java第三次(复习和总结和10月08日所学异常)

复习:

1.类
类：将具有共同特征和行为的一类实体的集合
普通类：能够实例化对象，调用方法，赋值
抽象类：可以有抽象方法，但是抽象方法不能有方法体（不能有具体实现的大括号),可以定义普通方法,有构造方法,不能new对象
接口类：可以被调用，可以被继承
接口的特点:
接口就是一种引用数据类型
接口中只能定义常量和方法（抽象方法，静态方法，默认方法，私有方法）
接口不能定义成员变量和构造方法
接口不能创建对象，只能通过其实现类来使用
静态类：在java不存在，在NET中存在
接口和抽象类很类似，但是有区别:
抽象类中可以有抽象方法和非抽象方法，
抽象类中可以有局部变量和成员变量
jdk1.8之前接口只能有抽象方法。1.8以后可以有静态方法和default默认方法
接口中能够定义静态变量和final常量
一个类可以实现多个接口，但是只能实现一个抽象类
对象:
通过类的构造方法进行实例化( new出来的)对象一 定要指向具体的个体才能称为实体单继承
子类拥有父类的所有特征,并能有自己独特的属性和行为
实现:解决类只能单继承的问题
多态:Java的多态性表现为两种：一是重写override和重载overload。重写override是父类和子类之间多态性的一种表现，重载overload是同一个类中多态性的一种表现。

重写override：如果子类中定义了某方法与父类中的方法函数名相同且参数一样，那么该方法被重写override，子类的对象使用这个方法时调用的是子类的定义，对它而言，父类的定义如同被屏蔽了。重写的方法不能改变返回值的类型。对于重写方法的选择是动态的，选择重写方法的版本是在运行时进行的，选择的依据是被调用方法所在对象的运行时类型。

重载overload：如果在一个类中定义了多个同名的方法，它们或者有不同的参数个数，或者有不同的参数类型，这种现象称为方法的重载overload，重载的方法可以改变返回值的类型。对于重载方法的选择是静态的，要调用哪个重载方法是在编译器做出决定的。
继承:
子类的创建的对象指向父类
运行机制:执行的过程必须先执行父类的构造方法,然后再执行子类的构造方法,然后再执行对应的方法
单继承 多实现
2.数组
数组:数组是用于储存多个相同类型数据的集合。
数组语法:类型 [] 数组名 = new 类型[数组固定长度]
使用数组:
for循环 if条件判断 索引
3.单元测试
@Test pom.xml jar包
单元测试只能调用本单元的内容
4.内部类
一个类嵌套另一个类，嵌套的那个类进称为内部类
内部类∶
①静态内部类中可以有非静态的方法
②当内部类中有静态方法或者静态成员变量时，一定是静态内部类
使用方法
外部类.内部类 类名 = new 外部类().new 内部类()
通过类名调用内部类方法
内部类的实例化
第一种
1、先实例化外部类对象
2、外部类对象.new 内部类（）

第二种
1、在外部类中创建返回值为内部类的方法
2、实例化外部类
3、外部类对象调用返回值为内部类方法进行实例化内部类
示例代码

package com.hp.test1;

public class Teacher {
    public void Teach(){
        System.out.println("外部类的方法");
    }
    //类里边嵌套了一个类就叫内部类
    class OperClass{
        public void play() {
            System.out.println("内部类的方法");
        }
    }
    //通过面向对象调用
    public OperClass getOperClass(){
        //OperClass operClass = new OperClass();
        return new OperClass();
    }
}

package com.hp.test1;

public class Test {
    public static void main(String[] args) {
        Teacher teacher = new Teacher();
        teacher.Teach();
        //第一种方式 外部类的对象.new 内部类(),实例出来的对象就能调用内部类的方法
        Teacher.OperClass operClass = teacher.new OperClass();
        operClass.play();
        //第二种
        Teacher.OperClass operClass1 = teacher.getOperClass();
        operClass1.play();
    }
}

笔记

课前提问
1.String和StringBuffer、StringBuilder的区别是什么？String为什么是不可变的
一、区别
1、String是字符串常量，而StringBuffer和StringBuilder是字符串变量。由String创建的字符内容是不可改变的，而由StringBuffer和StringBuidler创建的字符内容是可以改变的。
2、StringBuffer是线程安全的，而StringBuilder是非线程安全的。StringBuilder是从JDK 5开始，为StringBuffer类补充的一个单线程的等价类。我们在使用时应优先考虑使用StringBuilder，因为它支持StringBuffer的所有操作，但是因为它不执行同步，不会有线程安全带来额外的系统消耗，所以速度更快。
二、String为什么不可变
虽然String、StringBuffer和StringBuilder都是final类，它们生成的对象都是不可变的，而且它们内部也都是靠char数组实现的，但是不同之处在于，String类中定义的char数组是final的，而StringBuffer和StringBuilder都是继承自AbstractStringBuilder类，它们的内部实现都是靠这个父类完成的，而这个父类中定义的char数组只是一个普通是私有变量，可以用append追加。因为AbstractStringBuilder实现了Appendable接口。
2.自动装箱与拆箱
自动装箱就是Java自动将原始类型值转换成对应的对象，比如将int的变量转换成Integer对象，这个过程叫做装箱，反之将Integer对象转换成int类型值，这个过程叫做拆箱。因为这里的装箱和拆箱是自动进行的非人为转换，所以就称作为自动装箱和拆箱。原始类型byte,short,char,int,long,float,double和boolean对应的封装类为Byte,Short,Character,Integer,Long,Float,Double,Boolean。
3.ArrayList、LinkedList、Vector 的区别。
ArrayList
1）只能装入引用对象（基本类型要转换为封装类）；
2）线程不安全；
3）底层由数组实现
4）插入速度相对较慢，查询速度相对较快
Vector：
1）只能装入引用对象（基本类型要转换为封装类）；
2）Vector通过synchronized方法保证线程安全；
3）底层也由数组实现
4）插入速度相对较慢，查询速度相对较快
LinkedList
1）只能装入引用对象（基本类型会转换为封装类）；
2）线程不安全；
3）底层实现为双线链表
4）插入速度较快,而查询速度较慢
由于 Vevtor 使用了线程安全锁，所以ArrayList 的运行效率高于Vector。
1）异常
exception:异常
异常:程序在执行的过程中，出现了与程序员预期不一致或者不一样效果时，此问题可预期、可解决称为异常
error:错误
错误:不能预料、不可抗拒。由于操作系统或者环境导致的称为错误
异常的语法:
2)自定义异常
1、建立异常类
继承exception类
2、需要借助子类构造方法进行输出错误信息
3、建立对象异常代码、借助异常类的成员变量来实现异常的调用
throw 和throws 关键字的区别
1、写法上 : throw 在方法体内使用，throws 函数名后或者参数列表后方法体前
2、意义 ： throw 强调动作，而throws 表示一种倾向、可能但不一定实际发生
3、throws 后面跟的是异常类，可以一个，可以多个，多个用逗号隔开。throw 后跟的是异常对象，或者异常对象的引用。
4、throws 用户抛出异常，当在当前方法中抛出异常后，当前方法执行结束（throws 后，如果有finally语句的话，会执行到finally语句后再结束。）。可以理解成return一样。

package com.hp.exceptionDemo;

public class CostomizeExceptionDemo extends Exception{
    //通过子类调用父类异常的方法

    public CostomizeExceptionDemo(String message) {
        super(message);
    }
}

package com.hp.exceptionDemo;

public interface IStudent {
    //添加 自定义接口
    public void add(Student stu) throws CostomizeExceptionDemo;
}

package com.hp.exceptionDemo;

public class Student {
    private int id;
    private String name;
    private int age;

    public Student() {
    }

    public Student(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public void setId(int id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

package com.hp.exceptionDemo;

import org.junit.Test;

public class StudentImpl implements IStudent{
    //定义数组长度
    static int total=2;
    static int count=0;
    Student [] stus = new Student[total];
    @Override
    public void add(Student stu) throws CostomizeExceptionDemo {
            if(count<total){
                stus[count]=stu;
                count++;
            }else{
                throw new CostomizeExceptionDemo("数组已满，越界");
            }
    }

    @Test
    public void test1() throws CostomizeExceptionDemo{
        StudentImpl si = new StudentImpl();
        Student student1 = new Student(1,"",18);
        Student student2 = new Student(2,"",18);
//        Student student3 = new Student(2,"",18);
        si.add(student1);
        si.add(student2);
//        si.add(student3);
    }
}