JavaSE

• 00基本语法
• 0-1文档注释
• 0-2变量分类
• 0-3运算符
• 0-4流程控制
• 0-5数组
• 01面向对象
• 1-1类
• 1-2权限修饰符
• 1-3类的成员
• 1-3-1属性
• 1-3-2方法
• 1-3-3构造器
• 1-3-4代码块
• 1-3-5内部类
• 1-4三大特征
• 1-4-1封装
• 1-4-2继承
• 1-4-3多态
• 1-5关键字
• 1-5-1package
• 1-5-2import
• 1-5-3this
• 1-5-4super
• 1-5-5static
• 1-5-6final
• 1-5-7static final
• 1-5-8abstract
• 1-5-9interface
• 1-6面向对象其它知识点
• 1-6-1匿名对象的使用
• 1-6-2方法的重载
• 1-6-3可变个数形参
• 1-6-4属性赋值的先后顺序
• 1-6-5方法的重写(覆盖、重置)
• 1-6-6子类对象实例化的全过程
• 1-6-7Math.random()使用
• 02异常(广义上的异常)
• 2-1理解
• 2-2分类
• 2-3对于Exception(狭义异常)的处理机制
• 2-4体会
• 2-5开发中如何选择try-catch-finally和thorws
• 2-6如何自定义异常类
• 03多线程
• 3-1概述
• 3-2线程的分类
• 3-3线程的创建和使用【主要指的是用户线程】
• 3-4Thread类的有关方法
• 3-5线程的优先级
• 3-6线程的生命周期
• 3-7线程安全问题
• 3-8死锁
• 3-9线程的通信
• 3-10sleep()和wait()方法的异同
• 04常用类
• 4-1Object类
• 4-2包装类
• 4-2-1基本数据类型、包装类、String之间的转换
• 4-2-2两道面试题
• 4-3String
• 4-3-1String概述
• 4-3-2定义方式
• 4-3-3字符串特性
• 4-3-4常用方法
• 4-3-5String与其它类型之间的转换
• 4-3-6String的源码分析
• 4-3-7与String相关的类
• 4-4JDK8之前日期和时间API
• 4-4-1System.类中的current TimeMillis()
• 4-4-2两个Date类的使用
• 4-4-3SimpleDateFormat
• 4-4-4Calendar日历类(抽象类)的使用
• 4-5JDK8新日期和时间API
• 4-5-1Instant
• 4-5-2DateTimeFormatter类似于SimpleDateFormat
• 4-6Java比较器的使用
• 4-7其他常用类
• 4-7-1System类
• 4-7-2Math类
• 4-7-3BigInteger和BigDecimal
• 05枚举类
• 5-1理解
• 5-2如何定义枚举类
• 方式一jdk5.0之前，自定义枚举类
• 方式二jdk5.0之后，可以使用enum关键字定义枚举类
• 5-3Enum类的主要方法
• 5-4使用enum关键字定义的枚举类实现接口的情况
• 06注解
• 6-1概述
• 6-2常见的Annotation示例
• 6-3如何自定义注解:参照@SuppressWarnings定义
• 6-4JDK提供的四种元注解（用于修饰注解的注解）
• 6-5jdk8中注解的新特性：可重复注解、类型注解
• 6-5-1可重复注解
• 6-5-类型注解
• 07集合
• 7-1集合框架的概述
• 7-2Collection接口中的方法的使用
• 7-2-1集合元素的遍历操作,使用Iterator接口
• 7-2-2foreach 循环遍历集合或者数组
• 7-3Collection子接口
• 7-3-1List接口
• 7-3-2ArrayList的源码分析
• 7-3-3LinkedList源码分析
• 7-3-4Vector源码分析
• 7-3-5List接口中常用方法
• 7-3-6Set接口
• 7-3-7Set存储数据特点的理解
• 7-3-8关于HashCode和equals()方法的重写
• 7-3-9LinkedHashSet 的使用
• 7-3-10TreeSet
• 7-4Map接口
• 7-4-1Map接口及其多个实现类的对比
• 7-4-2Map中存储key-value的特点
• 7-4-3HashMap的底层的实现原理
• 7-4-4HashMap源码中的重要常量
• 7-4-5HashMap在jdk7中的源码分析
• 7-4-6HashMap在jdk8中的源码分析
• 7-4-7LinkedHashMap的底层实现
• 7-4-8Map中的常用方法
• 7-4-9TreeMap两种添加方式的使用
• 7-4-10Properties处理属性文件
• 7-4-11Collections工具类的常用方法测试
• 08泛型
• 8-1概述
• 8-2使用
• 8-3如何自定义泛型结构(泛型类、泛型接口;泛型方法)
• 8-4泛型在继承方面的体现
• 8-5通配符的使用
• 09IO
• 9-1File类的使用
• 9-1-1概述
• 9-1-2如何创建File类的实例
• 9-1-3File类的常用方法
• 9-1-4遍历、删除目录
• 9-2IO流原理及流的分类
• 9-2-1原理
• 9-2-2流的分类
• 9-2-3IO流体系
• 9-2-4节点流之一FileReader读入数据的基本操作
• 9-2-5节点流之一FileWriter写出数据的操作
• 9-2-6节点流之FileInputStream/FileOutputStream
• 9-2-7处理流之缓冲流
• 9-2-8处理流之转换流
• 9-2-9处理流之标准的输入输出流
• 9-2-10处理流之打印流
• 9-3-11处理流之数据流
• 9-2-12处理流之对象流
• 9-2-13RandomAccessFile
• 9-2-14【当前阶段不重要，可以不看】
• 10网络编程
• 10-1网络编程概述
• 10-2通信要素
• 10-3TCP编程
• 10-4UDP编程
• 10-5URL
• 11反射
• 11-1概述
• 11-2代码层面理解
• 11-3利用反射调用类的私有结构
• 11-4如何看待反射和封装性
• 11-5关于Class类的理解
• 11-6获取Class实例的4种方式
• 11-7Class实例对应的结构
• 11-8类的加载与ClassLoader理解
• 11-8-1类的加载过程理解
• 11-8-2ClassLoader的理解
• 11-8-3利用ClassLoader读取配置文件
• 11-9创建运行时类的对象
• 11-10体会反射的动态性
• 11-11获取运行时类的属性结构及其内部结构
• 11-12获取运行时类的方法结构
• 11-13获取运行时类的构造器结构
• 11-14获取运行时类的父类及父类的泛型
• 11-15获取运行时类的接口、所在包、注解等
• 11-15获取运行时类中指定的属性
• 11-15获取运行时类中指定的方法
• 11-16获取运行时类中指定的构造器
• 12动态代理
• 12-1动态代理的举例
• 13jdk8其它新特性
• 13-1Lambda表达式
• 13-2Lambda表达式的使用
• 13-3函数式接口
• 13-4方法引用
• 13-5构造器引用
• 13-6数组引用
• 13-7Stream API
• 13-7-1创建Stream的方式
• 13-7-2Stream的中间操作
• 13-7-3Stream的终止操作
• 13-8Optional类
• 13-8-1使用举例
• 14拓展
• 14-1JavaBean
• 14-2MVC设计模式
• 14-3JDK中主要包的介绍
• 14-4设计模式

00基本语法

0-1文档注释

①文档注释用javadoc来解析,在Dos中输入一下命令
②javadoc -d (要生成的)文件夹的名字 -author -version 文件名(.java结尾的文件名)
③执行完命令后，会在当前的目录下创建一个文件夹，其中的index.html即为该程序的说明文档

0-2变量分类

1、byte byteNum = 128;(该语句编译时报错，因为byte数据类型的表数范围为-128~127)

2、声明long类型的变量，必须以“l”或“L”结尾；声明float类型的变量，必须以“f”或“F”结尾；

3、使用整型变量通常用int，使用浮点型变量通常用double

4、char类型的三种表现形式：
******用一对’’,内部只能写一个字符，如char charNum = ‘9’;
******可以是转义字符如：char charNum = ‘\n’;
******可以是Unicode码(如：\u000a表示\n)【16进制4位数】

5、java中的boolean类型值是true false，不像C语言用1和0表示真假

6、 基本数据类型之间的运算规则(只讨论7种基本数据类型之间的运算，不包含boolean类型)

①自动类型提升(容量小的数据类型的变量与容量大的数据类型的变量运算，结果的数据类型为容量大的数据类型)
注意：【是容量小的->容量大的 不是 占内存空间小的->占内存空间的大的;】【byte,short,char之间做运算，结果的数据类型是int。(byte、short、char)->int->long->float->double】

System.out.println(1F+1L);// 2.0 【容量小的long类型转换为容量大的float类型】

②强制类型转换【不再阐述】

0-3运算符

算术运算符
+ - * / %
赋值运算符
+= -= *= /= %=
比较运算符
> < == != >= <= instanceof
逻辑运算符
& && | || ^ !
位运算符
& | ~ ^ >> >>> <<
三元运算符
? :

public class V01Operator {
    public static void main(String[] args) {
        short shortNum = 10;
        // 如果要对short类型的变量实现增值操作 shortNum = (short) (shortNum + 3);但是++ -- += -= *= /= %=不会改变结果的类型
        shortNum = (short) (shortNum + 3); // shortNum = 13
        shortNum += 7; // shortNum = 20
        System.out.println(shortNum);
    }
}

【注意】++ – += -= *= /= %=不会改变结果的类型【具体见上述代码】

0-4流程控制

public class V03ProcessControl {
    public static void main(String[] args) {
        int i = 0;
        for(System.out.print("a");i < 3; System.out.print("c") , i++){
            System.out.print("b");
        }// 结果是abcbcbc
        for(int j = 0;j < 3;j++){
            System.out.println("Hello World!");
        }
        System.out.println(i);// 结果是3------因为变量i没有在for循环内定义，所以在for循环的外面有效，可以使用。
         // System.out.println(j); 该语句编译出错，变量j只在for循环内有效
        for(int j = 1;j <= 150;j++){
            System.out.print(j);
            if(j % 3 == 0){
                System.out.print("->3的倍数");
            }
            if(j % 5 == 0){
                System.out.print("->5的倍数");
            }
            if(j % 7 == 0){
                System.out.print("->7的倍数");
            }
            System.out.println();
            // for(;;)相当于是while(true)
        }
    }
}

0-5数组

public class V04Array {
    
    public static void main(String[] args){
        //1、一维数组的声明与初始化
        //静态初始化：数组的初始化与数组元素的赋值是同时进行的
        int[] numbers = new int[]{11, 12, 13, 14, 15};// 第二种写法(类型推断)：int [] nubmers = {1,2,3,3,4}
        //动态初始化：数组先初始化，之后再对数组元素进行赋值
        int[] numbers1 = new int[7];
        numbers1[0] = 11;
        numbers1[1] = 12;
        numbers1[2] = 13;
        numbers1[3] = 14;
        //2、获取数组的长度(应用属性：length)
        System.out.println(numbers.length + " " + numbers1.length);
        

        
        //1、静态初始化
        int[][] arr = new int[][]{{1,2,3},{4,5,6}};
        //2、动态初始化
        int[][] arr1 = new int[2][3];
        int[][] arr2 = new int[2][];
        arr2[0] = new int[3];
        System.out.println(arr2[1]);
        //3、其余的写法int[][] arr;int[] arr[];int arr[][];
        

        //初始化数组
        int test[][] = new int[5][];
        for(int i = 0;i < test.length;i++){
            test[i] = new int[i + 1];
        }
        //遍历数组
        for(int i = 0;i < test.length;i++){
            for(int j = 0;j < test[i].length;j++){
                System.out.print(test[i][j]);
            }
            System.out.println();
        }
    }
}

01面向对象

1-1类

一、类和对象的理解
1、类：是对一类事物的描述，是抽象的概念上的定义
2、对象：是实际存在的该类实物的实体，因此也称实例(instance)
3、面向对象程序设计的重点是类的设计
4、设计类就是设计类的成员
二、类和对象的使用（面向对象思想落地的实现）
1、创建类、设计类的成员
2、创建类的对象
3、通过"对象.属性"、"对象.方法"调用对象的结构*/

public class V00HelloWorld {
    public static void main(String[] args){
        Person p1 = new Person();
        p1.age = 10;
        System.out.println(p1.age);
        p1.eat();
        p1.talk("中文");
    }
}
class Person{
    int age = 1;
    public void eat(){
        System.out.println("人吃饭");
    }
    public void talk(String language){
        System.out.println("人说" + language);
    }
}

1-2权限修饰符

用来修饰类、属性、方法、构造器、内部类
public------当前工程下可见
protected------不同包的子类可见
缺省------当前包下可见
private------类内部可见
【注意】：类只能被public和缺省修饰

1-3类的成员

1-3-1属性

1-3-2方法

1-3-3构造器

public class V06Constructor {
    public static void main(String[] args){
        Person1 p = new Person1();
    }
}
class Person1{
    //构造器
    public Person1(){
        System.out.println("自定义空参构造器！");
    }
}

1-3-4代码块

1、作用：来初始化类、对象
2、修饰：只能被static修饰
3、分类
4、属性赋值的先后顺序

1-3-5内部类

1、创建非静态成员内部类对象；创建静态成员内部类对象

public class InnerClass {
    public static void main(String[] args) {
        //创建静态成员内部类对象
        Pet.Dog dog = new Pet.Dog();
        //创建非静态成员内部类对象
        Pet pet = new Pet();
        Pet.Bird bird = pet.new Bird();
    }
}
class Pet{
    String name;
    static class Dog{
        String name;
    }
    class Bird{
        String name;
        public void display(String name){
            System.out.println(name);//调用形参的name
            System.out.println(this.name);//调用Bird类中的name
            System.out.println(Pet.this.name);//调用Pet的name
        }
    }
}

2、局部内部类使用

public class InnerClass2 {

}
class Pet2{
    //开发中局部内部类，一般用于方法中，返回该内部类的对象

    //返回一个实现了Comparable接口的内部类对象
    public Comparable getComparable(){
        //方式一
        class MyComparable implements Comparable{
            @Override
            public int compareTo(Object o) {
                return 0;
            }
        }
        return new MyComparable();
    }
    public Comparable getComparable2(){
        //方式二
        return new Comparable() {
            @Override
            public int compareTo(Object o) {
                return 0;
            }
        };
    }
    //局部内部类使用在方法中的一个注意点
    public void method(){
        
        //局部变量num
        int num = 0;
        class Inner{
            public void show(){
                System.out.println(num);
            }
        }
    }
}

1-4三大特征

1-4-1封装

public class V04Encapsulation {
    public static void main(String[] args){

    }
}
class Animal{
    private int age;

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

1-4-2继承

public class Person {
    int age;
    String name;
    char gender;
    public Person(){}
    public Person(int age,String name,char gender){
        this.age = age;
        this.name = name;
        this.gender = gender;
    }
    public void eat(){
        System.out.println("吃饭");
    }
    public void sleep(){
        System.out.println("睡觉");
    }
    public void setAge(int age){
        this.age = age;
    }
    public int getAge(){
        return this.age;
    }
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return this.name;
    }
    public void setGender(char gender){
        this.gender = gender;
    }
    public char getGender(){
        return this.gender;
    }
}

public class Student extends Person {
    
    public void study(){
        System.out.println("学习");
    }
    public void eat(){
        System.out.println("学生吃饭");
    }

}

public class ExtendsTest {
    public static void main(String[] args) {
        Student student = new Student();
        //调用父类的方法
        student.setAge(10);
        System.out.println(student.getAge());
        //调用自己方法
        student.study();
    }
}

1-4-3多态

1、核心内容

2、扩展内容

1-5关键字

1-5-1package

1-5-2import

import static java.lang.System.*;
public class TestImport {
    public static void main(String[] args) {
        out.println("HelloWorld");
    }
}

1-5-3this

1-5-4super

1-5-5static

一、可以修饰属性、方法、代码块、内部类

二、开发中如何确定一个属性要声明为static
1、属性是可以被多个对象所共享的，不会随着对象的不同而不同的。
2、类中的常量也常常声明为static

三、开发中如何确定一个方法要声明为static
1、操作静态属性的方法，通常设置为static的
2、工具类中的方法，习惯上声明为static的。比如: Math、 Arrays、collections

四、static的应用
1、单例模式

public class TestSingleton {
    public static void main(String[] args) {
        //获取饿汉式对象
        Singleton1 instance1 = Singleton1.getInstance();
        //获取懒汉式对象
        Singleton2 instance2 = Singleton2.getInstance();
    }
}
class Singleton1{
    //饿汉式(线程安全)
    private Singleton1(){}
    private static Singleton1 instance = new Singleton1();
    public static Singleton1 getInstance(){
        return instance;
    }
}
class Singleton2{
    //懒汉式(①懒汉式延迟创建对象②目前代码是线程不安全的)
    private Singleton2(){}
    private static Singleton2 instance = null;
    public static Singleton2 getInstance(){
        if(instance == null){
            instance = new Singleton2();
        }
        return instance;
    }

}

①jdk源码中使用的例子：

②应用场景

2、main()方法的使用说明
①main方法作为程序的入口
②main方法也是一个普通的静态方法
③main方法可以作为我们与控制台交互的方式
运行的时候可以为String[] args传入参数

1-5-6final

一、表示最终的
二、可以修饰的结构
1、类
①表明此类不能被继承
②比如：String、StringBuffer、StringBuilder
2、变量
①表明此时的变量是一个常量
②修饰属性
③修饰局部变量
尤其是使用final修饰形参时，表明此形参是一个常量。 当我们调用此方法时， 给常量形参赋一个实参。赋值以后，就只能在方法体内使用此形参，但不能进行重新赋值
3、方法
①表明此方法不可以被重写
②例如：Object中的getClass()
4、内部类

1-5-7static final

用来修饰属性，表示全局常量

1-5-8abstract

一、可以修饰的结构
1、类

2、方法

3、注意点
4、①创建匿名子类的非匿名对象
Person是一个抽象类，eat(),breath()是其中的两个抽象方法

②创建匿名子类的匿名对象

1-5-9interface

一、如何定义接口(定义接口的成员)
①JDK7及之前：只能定义全局常量和抽象方法

②JDK8：

二、接口的使用

1-6面向对象其它知识点

1-6-1匿名对象的使用

常常作为参数

public class V01AnonymousObject {
    public static void main(String[] args){
        
        PhoneMall phoneMall = new PhoneMall();
        //匿名对象使用如下:
        phoneMall.showMessage(new Phone());
    }
}
class PhoneMall{
    public void showMessage(Phone p){
        System.out.println("手机品牌：" + p.brand + ";功能：" + p.function + ";手机屏幕尺寸：" + p.screenSize + "寸");
    }
}
class Phone{
    String brand;//手机品牌
    String function;//手机功能描述
    double screenSize;//手机屏幕尺寸
    public void showDescription(String modelNumber,String function,double screenSize){
        System.out.println("手机品牌：" + modelNumber + ";功能：" + function + ";手机屏幕尺寸：" + screenSize + "寸");
    }
}

1-6-2方法的重载

public class V02OverLoad {
    public static void main(String[] args) {
        //在一个类中，允许存在一个以上的同名方法，只要他们的参数个数或参数类型不同即可。(方法在同类中，同名，不同参数),以下三方法构成重载
        V02OverLoad v=new V02OverLoad();
        v.get(2,3);
    }
    public int getSum(int a,int b){
        return a + b;
    }
    public double getSum(double a,double b){
        return a + b;
    }
    public double getSum(int a,double b){
        return a + b;
    }

    public void get(double a,double b){
        System.out.println(a * b);
    }
    public void get(int a,int b){
        System.out.println(a + b);
    }

}

1-6-3可变个数形参

public class V03VariableNumberOfArguments {
    
    public static void main(String[] args) {

    }
    //3、可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
    //4、可变个数形参在方法的形参的中，只能声明在末尾==>一个方法的形参中只能声明一个可变个数形参
    public void show(String str,String ... strs){

    }
    public void show(String ... strs){
        //5、可变个数形参可以理解为同数组一样，因此在一个类中，形参是一个'可变个数形参'的方法，不能与形参是一个'数组'的方法构成重载
        for(int i = 0;i < strs.length;i++){
            System.out.println(strs[i]);
        }
    }
}

1-6-4属性赋值的先后顺序

①默认初始化
②显式初始化/代码块初始化
③构造器初始化
④通过‘对象.属性’或者‘对象.方法’赋值

1-6-5方法的重写(覆盖、重置)

1-6-6子类对象实例化的全过程

1-6-7Math.random()使用

//Math.random()得到的随机数范围是[0.0,1.0)（double类型）
//7、随机数的获取-获取[a,b]范围内的整数：(int)(Math.random()*(b - a + 1) + a)

02异常(广义上的异常)

2-1理解

①程序执行中发生的不正常情况
②开发过程中的语法错误和逻辑错误不是异常

2-2分类

一、Error

二、Exception

2-3对于Exception(狭义异常)的处理机制

对Exception(狭义异常)的处理机制就是抓抛模型(将"抛"出来的异常"抓"住)
其中抛有两种方式，抓也有两种方式

2-4体会

①开发中，由于运行时异常比较常见，所以我们通常就不针对运行时异常编写try-catch-finally了。针对于编译时异常，一定要考虑异常的处理。
②使用try-catch-finally处理编译时异常，使得程序在编译时就不再报错，但是运行时仍可能报错。相当于我们使用try- catch-finally将一个编译时可能出现的异常，延迟到运行时出现。

2-5开发中如何选择try-catch-finally和thorws

①如果父类中被重写的方法没有throws方式处理异常，则子类重写的方法也不能使用throws,意味着如果子类重写的方法中有异常，必须使用try-catch-finally方式处理。

②执行的方法a中，先后又调用了另外的几个方法，这几个方法是递进关系执行的。我们建议这几个方法使用throws的方式进行处理。而执行的方法a可以考虑使用try-catch-finally方式进行处理。

2-6如何自定义异常类

1、step1：继承现有的异常结构(RunTimeException、Exception)
2、step2：提供全局常量serialVersionUID
3、step3：提供重载的构造器

03多线程

3-1概述

1、关于进程和线程的概念及了解，大家可以百度，科班出身的码神应该已经学习了操作系统这门课，这门课讲解的很详细，码神们可以跳过这部分。

2、JVM简图如下

3、JVM允许程序运行多个线程，需要通过java.lang.Thread类体现

3-2线程的分类

3-3线程的创建和使用【主要指的是用户线程】

一、线程的创建
1、继承Thread类

2、实现Runnable接口

原理(JDK源码)：

public class V00ExtendsThread {
    public static void main(String[] args) {
        //方式一：继承Thread
        Window1 w1 = new Window1();
        Window1 w2 = new Window1();
        Window1 w3 = new Window1();
        w1.start();
        w2.start();
        w3.start();
        //方式二：实现Runnable接口
        Window2 window = new Window2();
        Thread t1 = new Thread(window);
        Thread t2 = new Thread(window);
        Thread t3 = new Thread(window);
        t1.start();
        t2.start();
        t3.start();
    }
}
class Window1 extends Thread{
    public static int ticketNum = 100;
    public void run(){
        while(true){
            if(ticketNum > 0){
                System.out.println(Thread.currentThread().getName() + "售出 =>【" + ticketNum + "】<= 号票");
                ticketNum--;
            }else break;
        }
    }
}
class Window2 implements Runnable{
    public int ticketNum = 100;
    public void run(){
        while(true){
            if(ticketNum > 0){
                System.out.println(Thread.currentThread().getName() + "售出 =>【" + ticketNum + "】<= 号票");
                ticketNum--;
            }else break;
        }
    }
}

3、两种创建方式的对比

二、JDK5.0新增的线程创建方式
1、实现Callable接口

如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程方式强大?

2、使用线程池

3-4Thread类的有关方法

3-5线程的优先级

3-6线程的生命周期

具体的请码神们百度或者参考操作系统

3-7线程安全问题

一、在Java中，通过线程同步解决线程安全问题
1、同步代码块

2、同步方法

3、Lock锁(JDK5.0新增)


4、synchronized与Lock 的异同 && 优先使用顺序

二、同步监视器

三、利用线程同步机制解决懒汉单例模式的线程安全

四、体会
①同步方式解决了线程的安全问题；
②操作同步代码时，只能有一个线程参与， 其他线程等待。相当于是一个单线程的过程，效率低。

3-8死锁

具体的请码神们百度或者参考操作系统

3-9线程的通信

3-10sleep()和wait()方法的异同

04常用类

4-1Object类

一、finalize()------对象被回收之前，会调用此方法。不要自己去调用，交给垃圾回收机制调用
二、clone()------克隆一个对象
三、toString()

四、equals(Object obj)

String类中重写的equals()方法

4-2包装类

4-2-1基本数据类型、包装类、String之间的转换

4-2-2两道面试题

说明：
Integer内部定义了IntegerCache结构，IntegerCache中定义了 Integer[]，保存了从- 128~127范围的整数。如果我们使用自动装箱的方式，给Integer赋值的范围在-128到127范围内时，可以直接使用数组中的元素，不用再去new了。

目的是提高效率

4-3String

4-3-1String概述

一、使用一对“”引起来
二、String类声明为final的表示不可以被继承
三、
①String实现了Serializable接口：表示字符串是支持序列化的
②实现了Comparable接口：表示可以比较大小
四、内部定义了final char[] value用于存储字符串数据
五、代表不可变的字符序列，简称不可变性

4-3-2定义方式

问题：String s = new String(“abc”);在内存中创建了几个对象?
两个
①一个是堆空间中new的结构
②一个是char[]对应的常量池中的数据

4-3-3字符串特性

4-3-4常用方法

1、subString(int beginIndex,int endIndex)是左闭右开
2、什么情况下，indexOf(str)和lastIndexOf(str)返回值相同?
①情况1：存在唯一的str
②情况2：不存在str

4-3-5String与其它类型之间的转换

一、String与基本数据类型、包装类之间的转换（具体见包装类）
二、String与char[]之间的转换

三、String与byte[]之间的转换

4-3-6String的源码分析

4-3-7与String相关的类

一、StringBuffer
1、StringBuffer源码分析

2、扩容问题




如果要添加的数据底层数组盛不下了，那就需要扩容底层的数组。
默认情况下，扩容为原来容量的2倍+2,同时将原有数组中的元素复制到新的数组中。

3、常用方法

二、StringBuilder

一、String、StringBuffer、StringBuilder三者的异同

二、指导意义
①开发中建议使用: StringBuffer(int capacity) 或StringBuilder(int capacity)
②三者的效率，StringBuilder > StringBuffer > String

4-4JDK8之前日期和时间API

4-4-1System.类中的current TimeMillis()

4-4-2两个Date类的使用

4-4-3SimpleDateFormat

一、两个操作
1、格式化(日期—>字符串)
2、解析(字符串—>日期)
二、SimpleDateFormat的实例化

public class Test {
    public static void main(String[] args) throws ParseException {
        Date date = new Date();
        /
        Season[] seasons = Season.values();
        for (int i = 0; i < seasons.length; i++) {
            seasons[i].show();
        }
        //春天春天春天
        //夏天夏天夏天
        //秋天秋天秋天
        //冬天冬天冬天
    }
}
interface info{
    void show();
}
enum Season implements info{
    //1、提供当前枚举类的对象，多个对象之间用”,”隔开,末尾对象”;"结束
    SPRING("春","春暖花开"){
        @Override
        public void show(){
            System.out.println("春天春天春天");
        }
    },
    SUMMER("夏","夏日炎炎"){
        @Override
        public void show(){
            System.out.println("夏天夏天夏天");
        }
    },
    AUTUMN("秋","秋高气爽"){
        @Override
        public void show(){
            System.out.println("秋天秋天秋天");
        }
    },
    WINTER("冬","寒风刺骨"){
        @Override
        public void show(){
            System.out.println("冬天冬天冬天");
        }
    };
    //2、声明Season对象的属性:private final 修饰
    private final String seasonName;
    private final String seasonDesc;
    //3、私有化类的构造器，并给对象属性赋值
    private Season(String seasonName,String seasonDesc){
        this.seasonName = seasonName;
        this.seasonDesc = seasonDesc;
    }

    //4、其它诉求1：获取枚举类对象的属性
    public String getSeasonName(){
        return this.seasonName;
    }
    public String getSeasonDesc(){
        return this.seasonDesc;
    }
}

06注解

6-1概述

6-2常见的Annotation示例

6-3如何自定义注解:参照@SuppressWarnings定义

定义注解必须配上注解的信息处理流程才有意义
一、注解声明为@interface
public @interface Suppres sWarnings

6-4JDK提供的四种元注解（用于修饰注解的注解）

JDK5.0提供了4个标准的meta-annotation类型， 分别是：
一、Retention

二、Target

自定义注解通常都会指明两个元注解: Retention、 Target

三、Documented
四、Inherited

6-5jdk8中注解的新特性：可重复注解、类型注解

6-5-1可重复注解

①在MyAnnotation上声明@Repeatable,成员值为MyAnnotations. class
②MyAnnotation的Target和Retention等元注解与MyAnnotations相同。

6-5-类型注解

07集合

7-1集合框架的概述

一、集合、数组都是对多个数据进行存储操作的结构，简称Java容器。
说明:此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储(. txt,.jpg,.avi,数据库中的数据)

二、数组在存储多个数据方面的特点:
1、一旦初始化以后，其长度就确定了。
2、数组一旦定义好，其元素的类型也就确定了。我们也就只能操作指定类型的数据了。比如: String[] arr;int[] arr1;object[] arr2;
3、数组在存储多个数据方面的缺点: .
①一旦初始化以后，其长度就不可修改。
②数组中提供的方法非常有限，对于添加、删除、插入数据等操作，非常不便，同时效率不高。
③获取数组中实际元素的个数的需求，数组没有现成的属性或方法可用
④数组存储数据的特点:有序、可重复。对于无序、不可重复的需求，不能满足。

三、Java集合可以分为Collection和Map两种体系
Collection接口：单列数据，定义了存取一组对象的方法的集合

List: 元素有序、可重复的集合
Set:元素无序、不可重复的集合

Map接口：双列数据，保存具有映射关系“key-value对”的集合

7-2Collection接口中的方法的使用

向Collection接口的实现类的对象中添加数据obj时，要求obj所在类要重写equals().【contains(Object obj)方法，会将obj与集合中的元素逐一进行equals()比较;remove(Object obj)、removeAll(Collection coll1)方法也会调用equals()方法】
java.lang.UnsupportedOperationException解决方法

public class Test {
    public static void main(String[] args) throws ParseException {
        /
            //3.读入操作(方式二)
            while((len = fr.read(cbuf)) != -1){
                System.out.print(new String(cbuf,0,len));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            //3.流的关闭操作
            try {
                if(fr != null){
                    fr.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

9-2-5节点流之一FileWriter写出数据的操作

public class Test {
    public static void main(String[] args) {
        FileWriter fw = null;
        try {
            //1.实例化File类的对象，指明要操作的文件
            File file = new File("c://Users//18369//Desktop//helloworldout.txt");
            //2.提供具体的流
            fw = new FileWriter(file);
            //3.写出数据
            fw.write("哈哈哈哈！");
        }catch(IOException e){
            e.printStackTrace();
        }finally{
            if(fw != null){
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

文件的复制操作

9-2-6节点流之FileInputStream/FileOutputStream

复制文件

public class Test {
    public static void main(String[] args) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            File src = new File("G://html_code//img//2.jpg");
            File dest = new File("c://Users//18369//Desktop//copy.jpg");
            fis = new FileInputStream(src);
            fos = new FileOutputStream(dest);
            int len;
            byte[] buf = new byte[5];
            while((len = fis.read(buf)) != -1){
                fos.write(buf,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            if(fis != null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(fos != null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

9-2-7处理流之缓冲流

使用BufferedReader、BufferedWriter复制文件

使用BufferedInputStream、BufferedOutputStream复制文件

public class Test {
    public static void main(String[] args) {
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            //1.造文件
            File src = new File("G://html_code//img/py3.jpg");
            File dest = new File("C://Users//18369//desktop//copy.jpg");
            //2.造流
            //2.1造节点流
            FileInputStream fis = new FileInputStream(src);
            FileOutputStream fos = new FileOutputStream(dest);
            //2.2造缓冲流
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);
            //3.复制的细节：读取、写入
            int len;
            byte[] buf = new byte[10];
            while((len = bis.read(buf)) != -1){
                bos.write(buf,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            if(bis != null){
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(bos != null){
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        //4.资源关闭
        //要求1：先关闭外层的流，再关闭内层的流
        //说明：关闭外层流的同时，内层流也会自动的进行关闭。关于内层流的关闭，我们可以省略
    }
}

统计字符个数

9-2-8处理流之转换流

InputStreamReader的使用，实现字节的输入流到字符的输入流的转换

综合使用InpuStreamReader、OutputStreamWriter(读取编码格式为utf-8的文件，并将其以gbk编码方式输出)

9-2-9处理流之标准的输入输出流

9-2-10处理流之打印流

9-3-11处理流之数据流

作用：用于读取或写出基本数据类型的变量或字符串

9-2-12处理流之对象流

对象的序列化机制【重点 只是借助对象流来讲解】

一、序列化过程

二、反序列化过程

三、自定义类实现序列化和反序列化的操作
1、自定义可序列化类的要求

2、serialVersionUID的理解

3、实际中使用JSON将对象变为字符串，再进行序列化

9-2-13RandomAccessFile

一、实现数据的读写操作





二、实现数据的插入

9-2-14【当前阶段不重要，可以不看】

10网络编程

10-1网络编程概述

10-2通信要素

一、IP



二、端口号

三、协议

10-3TCP编程

一、



二、
由于read方法是阻塞的所以服务器端一直等待客户端的数据发送。不会执行之后的代码。所以需要客户端关闭数据输出告诉给服务器终止发送，让其停止接收。

10-4UDP编程

10-5URL

11反射

11-1概述

Class是用来描述类的类

11-2代码层面理解

反射之前的操作

利用反射的操作

11-3利用反射调用类的私有结构

一、在Person类外部， 不可以通过Person类的对象调用其内部私有结构。
二、通过反射，可以调用Person类的私有结构的。比如:私有的构造器、方法、属性

public class Test {
    public static void main(String[] args) throws Exception {
        Class clazz = Person.class;
        Constructor cons = clazz.getDeclaredConstructor();
        Person p = (Person)cons.newInstance();
        //获取私有方法
        Method showNation = clazz.getDeclaredMethod("showNation", String.class);
        showNation.setAccessible(true);
        String nation = (String)showNation.invoke(p,"中国");//相当于String nation = p.showNation("中国");
    }
}
class Person{
    private String showNation(String nation){
        return nation;
    }
}

11-4如何看待反射和封装性

一、封装性是建议我们如何调用相关结构
二、反射解决的是我们能不能调用某些结构。二者并不矛盾

11-5关于Class类的理解

11-6获取Class实例的4种方式

常用第三种方式获取Class实例

11-7Class实例对应的结构

11-8类的加载与ClassLoader理解

11-8-1类的加载过程理解

11-8-2ClassLoader的理解

11-8-3利用ClassLoader读取配置文件

11-9创建运行时类的对象

11-10体会反射的动态性

11-11获取运行时类的属性结构及其内部结构

获取属性的内部结构

11-12获取运行时类的方法结构

获取运行时类的方法的内部结构



框架可以看做 注解+反射+设计模式

11-13获取运行时类的构造器结构

11-14获取运行时类的父类及父类的泛型

获取运行时类带泛型的父类


获取运行时类带泛型的父类的泛型

11-15获取运行时类的接口、所在包、注解等

获取接口

获取所在包

获取注解

11-15获取运行时类中指定的属性

getField()只能获取public的属性

11-15获取运行时类中指定的方法

11-16获取运行时类中指定的构造器

12动态代理

静态代理的特点：代理类和被代理类在编译期间就确定下来了

12-1动态代理的举例

二、

13jdk8其它新特性

13-1Lambda表达式

一、

二、

13-2Lambda表达式的使用

13-3函数式接口

13-4方法引用

一、


二、


三、

13-5构造器引用

13-6数组引用

13-7Stream API

13-7-1创建Stream的方式

一、通过集合


二、通过数组


三、通过Stream的of()


四、创建无线流

13-7-2Stream的中间操作

一、筛选与切片



二、映射



三、排序

13-7-3Stream的终止操作

一、匹配与查找





二、归约

三、收集


Collectors：

13-8Optional类

13-8-1使用举例

14拓展

14-1JavaBean

一、是一种Java编写的可重用组件
二、是指符合以下标准的Java类
1、类是公共的
2、有空参构造器
3、有属性及其对应的get、set方法

14-2MVC设计模式

一、将整个程序分为三个层次
1、视图层(view)：显示数据
2、模型层(model)：主要用来处理数据
3、控制层(controller)：处理业务逻辑
二、好处
1、这种将程序输入输出、数据处理，以及数据的展示分离开来的设计模式，使程序结构变的灵活而且清晰
2、同时也描述了程序各个对象间的通信方式，降低了程序的耦合性

14-3JDK中主要包的介绍

14-4设计模式

一、创建型模式(5种)
工厂方法模式
抽象工厂模式
单例模式
建造者模式
原型模式
二、结构型模式(7种)
适配器模式
装饰器模式
代理模式
外观模式
桥接模式
组合模式
享元模式
三、行为型模式(11种)
策略模式
模板方法模式
观察者模式
迭代子模式
责任链模式
命令模式
备忘录模式
状态模式
访问者模式
中介模式
解释器模式