JAVA基础

1：枚举：限定变量的取值只能为所给的；

enum size {S,M,L,XL};
size a = size.L;

2：一位数组初始化两种方式

int [] arr1 = new int[10];
int [] arr2 = new int[] {1,2,3,4,5,6,7,8,9,0};
System.out.println(Arrays.toString(arr1));
//[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
System.out.println(Arrays.toString(arr2));
//[1, 2, 3, 4, 5, 6, 7, 8, 9, 0]

基本数据 存放于 栈 内存中

引用数据类型（new 出来的）存放于 堆内存中

二：封装 继承 多态

被private修饰的方法无法重写和继承

被static 和 final 修饰的方法 无法重写但是可以继承

2.1：封装：对象代表什么 就封装对应的属性 并提供数据对应的行为； 创建对象会调用构造器（有虚拟机自动调用）[无参构造用于 对成员变量进行初始化  有参构造用于 对成员变量进行赋值]

三：接口和抽象类

3.1：接口中的抽象方法，默认方法，静态方法，私有方法(重点)

接口中除了抽象方法没有方法体，默认方法，静态方法都有

接口，是Java语言中一种引用类型，是方法的集合，如果说类的内部封装了成员变量、构造方法和成员方法，那么接口的内部主要就是封装了方法，包含抽象方法（JDK 7及以前），默认方法和静态方法（JDK 8），私有方法（JDK 9）。

接口的定义，它与定义类方式相似，但是使用 interface 关键字。它也会被编译成.class文件，但一定要明确它并不是类，而是另外一种引用数据类型。

1. 只能定义常量 public static final
2. 无构造方法 （不能创建实例对象）
3. 内部方法只能为抽象方法
4. JDK8以后多了静态方法（static 修饰 不可以重写）默认方法（default 修饰 可以不重写  接口.方法名  直接调用  或者用到再重写） JDK9多了 私有方法

非抽象子类实现接口：
1. 必须重写接口中所有抽象方法。
2. 继承了接口的默认方法，即可以直接调用，也可以重写。

如果接口中有多个抽象方法 要使用一个 可以  加一个适配器 重写口的抽象方法  实现类继承适配器

3.2 抽象类

抽象方法和抽象类  都必须要用abstract修饰  抽象方法也没有方法体

1. 只要有一个抽象方法 就算是抽象类 
2. 抽象类中 可以有普通方法
3. 抽象类不能例化对象
4. 子类继承抽象类必须重写全部抽象方法（或者子类也是抽象类）

接口是对行为的抽象

抽象类是对事物的抽象

---

设计模式：

单例模式：懒汉 饿汉

懒汉和饿汉的区别：

懒汉模式:在类加载的时候不被初始化。

饿汉模式:在类加载时就完成了初始化，但是加载比较慢，获取对象比较快。

饿汉模式是线程安全的，在类创建好一个静态对象提供给系统使用，懒汉模式在创建对象时不加上synchronized，会导致对象的访问不是线程安全的。

建造者模式：

Builder模式主要用于解决初始化类时(也就是new一个类的实例出来)，类的构造函数种类过多且不易管理的问题。

注意事项：与工厂模式的区别是：建造者模式更加关注与零件装配的顺序。

优点： 1、建造者独立，易扩展。 2、便于控制细节风险。

缺点： 1、产品必须有共同点，范围有限制。 2、如内部变化复杂，会有很多的建造类。

我们的想法是Student类的构造函数不要那么多，但是又要满足初始化Student类变量的需求。可以考虑设计一个内部类，这个内部类的参数跟Student类的参数一样，而Student类的构造函数的参数，我们就设定为这个内部类。因此，只需要将这个内部类的变量初始化即可。
内部类变量设定的时候，我们采用链式结构，这样可以通过setXX().setXX()形式一直写下去。

工厂模式：

根据传入参数的不同，返回不同的对象（系统的闹钟 就是用的这个 设计模式）

目的：解决接口选择问题
优点：想要创建对象，只要知道名字就行，屏蔽了内部实现，只要关心接口
缺点：增加一个产品的时候，需要增加一个实现类 和 一个工厂，

其实，无论是简单工厂模式、工厂模式还是抽象工厂模式，它们本质上都是将不变的部分提取出来，将可变的部分留作接口，以达到最大程度上的复用。究竟用哪种设计模式更适合，这要根据具体的业务需求来决定。

简单工厂一个工厂生产一种产品，抽象工厂一个工厂生产一系列产品。

public class Student{
        private String name;
        private int age;
        private boolean sex;
        
        public Student(){}
        
        public static StudentBuilder newInstance(){
            return new StudentBuilder();
        }
        
        static class StudentBuilder{
            private String name;
            private int age;
            private boolean sex;
            
            public StudentBuilder setName(String name){
                this.name = name;
                return this;
            }
            
            public StudentBuilder setAge(int age){
                this.age = age;
                return this;
            }
            
            public StudentBuilder setSex(boolean sex){
                this.sex = sex;
                return this;
            }
            
            public Student build(){
                return new Student();
            }
        }

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

4:字符缓存流读写文件

第一种 最好 效率高；

//第一种
BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\TestFile.txt"));

//第二种
BufferedWriter bw2 = 
new BufferedWriter(new OutputStreamWriter(new FileOutputStream("D:\\TestFile.txt")));

bw.write("Hello Worle"); //写
bw.nextline();  //换行
bw.flush();  //刷新
bw.close();

字符缓存流读文件

BufferedReader br = new BufferedReader(new FileReader("D:\\TestFile.txt"));
        
        //一次读一个字符数组
        char [] arr = new char[1024];
        int len;
        while ( (len = br.read(arr)) != -1){
            String s = new String( arr , 0 , len);
            System.out.println(s);
        }
        
        //一次读一行
        String temp;
        while ( (temp = br.readLine()) != null){
            System.out.println(temp);
        }

4:字节缓存流读写文件

//读文件
BufferedInputStream bis = 
new BufferedInputStream(new FileInputStream("D:\\TestFile.txt"));
        byte [] by = new byte[1024];
        int len = 0;
        while ( (len = bis.read(by)) != -1) {
            String s = new String(by ,0, len);
            System.out.println(s);
        }



//写文件
BufferedOutputStream bos = 
new BufferedOutputStream(new FileOutputStream("D:\\TestFile.txt"));
        bos.write("Hello World".getBytes());
        bos.close();

IO异常处理

放在try（）的括号里

把定义 IO流 放在Try里边 不用关闭流了

2：常见的异常类

NullPointerException：空指针异常；
SQLException：数据库相关的异常；
IndexOutOfBoundsException：数组下角标越界异常；
FileNotFoundException：打开文件失败时抛出；
IOException：当发生某种IO异常时抛出；
ClassCastException：当试图将对象强制转换为不是实例的子类时，抛出此异常；
NoSuchMethodException：无法找到某一方法时，抛出；
ArrayStoreException：试图将错误类型的对象存储到一个对象数组时抛出的异常；
NumberFormatException：当试图将字符串转换成数字时，失败了，抛出；
IllegalArgumentException 抛出的异常表明向方法传递了一个不合法或不正确的参数。
ArithmeticException当出现异常的运算条件时，抛出此异常。例如，一个整数“除以零”时，抛出此类的一个实例。