java学习第四步-java语法高级

1 面向对象变成

一切皆对象，先设计对象，再编程，自己编程指挥者，让对象去实现功能。

1.1 封装（只是1种思想）

1.2 继承（子类继承父类）

1.2.1（1）父类中非私有的直接被继承

1.2.2 什么时候用

1.2.3 可以多层继承，但是只能单继承

1.2.4 super(找到父类的对象)

1.2.5 super()继承父类的构造方法（只要是构造方法第一句都是它）

1.2.6 重写（子类重写父类方法）

重写是子类重写实现父类的方法；
重载是类内部有好几个方法一样，参数不一样的方法；

1.3 多态（重写是最最要的多态实现）

1.3.1

下面这个案例比较特殊，难记：
原因是第2张图片

1.3.2 转型（难懂）

1.3.3 instanceof (判断类型)

1.4 抽象类（定义父类时这个方法不好明确）

1.5 模板设计模式

1.6 代码块

1.7 接口(方法全是抽象方法)

抽象方法没有方法体，就是没有内容。

接口全是抽象方法，你实例化它，实例化对象也不能用这个方法呀

1.7.1 接口成员

1.7.2 jdk8对接口的成员方法做了修改

1.7.3 接口使用思路

1.7.4 接口和类

1.8 内部类

1.8.1 成员内部类

1.8.2 局部内部类

1.9 匿名内部类

1.10 lambad表达式

1.10.1 lambda能做的事情

使用lambad表达式的做法

1.10.2 lambda表达式格式

1.10.3 lambda表达式使用前提3个

还要加1个条件，就是有一个调用这个接口类型的方法

1.10.4 lambda简写规则

1.10.5 lambda和匿名内部类的区别

2 垃圾回收机制

3 集合（一个容器，包括字典、集合、列表等）

3.1 集合概述

就是一个容器，列表list、集合set、字典map都属于集合

3.1 集合和数组是两个并列的概念

不同之处：
（1）集合的长度是可变的，数组长度不可变；
（2）数组存放基本类型的数据类型和引用类型，集合用来存放对象的引用，不能存放基本数据类型；跟python中的数组和列表一样，集合也可以存放基本类型，只不过多 了一步地址引用。

（3）数组存放的数据类型必须相同，

3.2 对象数组

可以将类对象存为数组，由对象组成的数组。

3.3 集合(类似python的列表)

3.4 集合元素

3.5 集合的方法

3.6 迭代器Iterator(遍历集合的，next轮流取出)

3.6.1 创建和使用

很简单，3分钟掌握创建，迭代，和判断3个方法就行

3.6.2 什么类可以使用迭代器（继承了iterable的类都可以）

单列集合都可以
双列集合不可以（因为没继承iterable）

3.6.3 for(i:list)只能遍历不能修改元素

3.6.4 集合3种遍历方式

3.2 list（分为Arraylist和Linklist）

3.2.1 list常用方法

3.2.2 list与数组的区别

3.2.3 Arraylist动态数组(底层是数组实现的)

3.2.4 Linklist(底层是链表实现，可以存不同类型对象，定义为泛型就可以)

3.3 set (hashSet和TreeSet,不包含重复元素)

3.3.1 TreeSet

这里的定义不难，看黑马的集合教程。

3.3.2 TreeSet的底层是红黑树

3.3.3 树

插入平衡二叉树的4种情况：
（1）左左
（2）左右
（3）右左
（4）右右

3.3.4 红黑树

红黑树不是平衡二叉树

添加节点默认节点是红色效率最高

3.3.5 HashSet

3.4 map (hashMap和TreeMap,相当于字典,键值对)

3.4.1 entry对象（就是键值对）

3.4.2 主要方法

3.4.3 HashMap

3.4.4 TreeSet

存对象的时候必须要定义排序规则
第一种实现接口来定义规则

第2种使用匿名类

3.4.5 可变参数（…）

4 编程思想

4.1 分类思想（分工协作，专人干专事）

4.2 分包思想

包就是1个文件夹
定义com.hh.luxiao，就会以，号分割，得到一个3级的文件夹目录

4.3 可复用、可维护、可读性强

5 IO操作流stream

不同输入输出设备之间的数据传输抽象为流

5.1 流分为字节流和字符流

根据流传输的数据类型：

1. 字节流（以stream结尾）；
2. 字符流（以Reader和Writer结尾）；

根据流的操作方式：

1. 输入流（读取：从外界文件中读取数据到程序）
2. 输出流（写入：从程序输出到文件中）

5.2 通过字符流和字节流进制IO操作

java系列3 java文件IO操作
https://blog.csdn.net/xiaotiig/article/details/126030988

6 异常处理Throwable

6.1 系统错误Error

（1）这类是你编程的时候出现的系统性错误，比如少加分号；，
（2）这类错误无法使用异常处理语句处理

6.2 异常Exception（编译和运行异常）

6.2.1 运行时异常（一般由程序逻辑错误引起）

可以通过try…catch语句捕获；

6.2.2 非运行时异常

可以通过try…catch捕获处理，或者使用throws抛出；

6.3 捕获异常try…catch…finally

try: 可能会出错的代码块
catch：try中出错了由catch来获取
finally：可以有也可以无，只要有一定会执行。

6.4 自定义异常（定义类继承Exception）

7 枚举（就是一个类）

枚举可以定义在类内部，也可以定义在类外部。
枚举就是类，作用就是固定的定义了常量，比如男，女

8 泛型（使用一个模糊的类型替代具体类型）

泛型就是一个泛化模糊的概念，提升程序的泛化性能：
你定义的时候直接就确定了数据类型，之后想用其他类型就没法用
比如你定义了 int i; 到时候你想让i成为浮点型，你直接用一个T来代表这就是一个类型就行了。

9 数据库JDBC（Java DataBase Connectivity）

用它来操作数据库，5步
1 加载驱动程序
2 建立连接
3 向数据库发送SQL语句
4 处理返回语句
5 关闭连接

10 递归（自己调用自己，3个注意）

（1）程序结束条件
（2）最小化问题实现，程序调用自己
（3）程序的输出

方法调用是在栈里面运行

11 多线程

11.1 并发并行

11.2 进程和线程

11.3 多线程的实现3种方式

11.4 Run和Start方法

11.5 获取和设置线程名字

11.6 获取线程对象与休眠

11.7 设置线程优先级（setPerior）

11.8 守护线程

当普通线程不存在（执行完毕）了，它也就不执行了

11.9 线程安全（买票问题，需要用同步代码块）

让多个线程轮流去占用资源，而不是一起了


锁对象一定要唯一，看黑马的锁对象唯一教程视频

11.10 同步方法

11.11 Lock锁

11.12 死锁

11.13 生产者和消费者

12 网络编程（简单，5分钟搞懂）

12.1网络数据传输3要素

12.2 InetAddress(ip操作类)

12.3 端口

12.4 协议

12.5 UDP发送数据（发送和接收）

package com.itheima.socketdemo2;


import java.io.IOException;
import java.net.*;

public class ClientDemo {
    public static void main(String[] args) throws IOException {
        //1.找码头
        DatagramSocket ds = new DatagramSocket();
        //2.打包礼物
        //DatagramPacket​(byte[] buf, int length, InetAddress address, int port)
        String s = "送给村长老丈人的礼物";
        byte[] bytes = s.getBytes();
        InetAddress address = InetAddress.getByName("127.0.0.1");
        int port = 10000;
        DatagramPacket dp = new DatagramPacket(bytes,bytes.length,address,port);


        //3.由码头发送包裹
        ds.send(dp);

        //4.付钱走羊
        ds.close();
    }
}

package com.itheima.socketdemo2;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

public class ServerDemo {
    //注意点:
        //1.要先运行接收端,再运行发送端
        //2.如果接收端再启动之后,没有接收到数据,那么会死等(阻塞).
        //3.在接收数据的时候,需要调用一个getLength方法,表示接收到了多少字节
    public static void main(String[] args) throws IOException {
        //1.找码头     ---- 表示接收端从10000端口接收数据的.
        DatagramSocket ds = new DatagramSocket(10000);
        //2,创建一个新的箱子
        byte [] bytes = new byte[1024];
        DatagramPacket dp = new DatagramPacket(bytes,bytes.length);
        //3.接收礼物,把礼物放到新的箱子中
        System.out.println("-----------接收前----------");
        ds.receive(dp);
        System.out.println("------------接收后---------");
        //4.从新的箱子里面获取礼物
       // byte[] data = dp.getData();
        int length = dp.getLength();
        System.out.println(new String(bytes,0,length));
        //5.拿完走羊
        ds.close();
    }
}

12.6 单播、组播、广播

12.6 TCP发送协议

12.6.1 三次握手

12.6.2 四次分手

12.6.3 一个小案例，客户端和服务器通信

发送端

package com.itheima.socketdemo7;

import java.io.*;
import java.net.Socket;

public class ClientDemo {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("127.0.0.1",10000);

        OutputStream os = socket.getOutputStream();
        os.write("hello".getBytes());
       // os.close();如果在这里关流,会导致整个socket都无法使用
        socket.shutdownOutput();//仅仅关闭输出流.并写一个结束标记,对socket没有任何影响


        /*InputStream is = socket.getInputStream();
        int b;
        while((b = is.read()) !=-1){
            System.out.println((char) b);
        }*/

        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        String line;
        while((line = br.readLine())!=null){
            System.out.println(line);
        }
        br.close();
        os.close();
        socket.close();
    }
}

//接收端
package com.itheima.socketdemo7;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class ServerDemo {
    public static void main(String[] args) throws IOException {
        ServerSocket ss = new ServerSocket(10000);

        Socket accept = ss.accept();

        InputStream is = accept.getInputStream();
        int b;
        while((b = is.read())!=-1){
            System.out.println((char) b);
        }

        System.out.println("看看我执行了吗?");
       /* OutputStream os = accept.getOutputStream();
        os.write("你谁啊?".getBytes());*/
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(accept.getOutputStream()));//将字节流转换为字符流，解决中文乱码的问题
        bw.write("你谁啊?");
        bw.newLine();
        bw.flush();

        bw.close();
        is.close();
        accept.close();
        ss.close();
    }
}

12.6.4 一个小案例，客户端传输文件

//上传文件

public class ClientDemo {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("127.0.0.1",10000);

        //是本地的流,用来读取本地文件的.
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("socketmodule\\ClientDir\\1.jpg"));

        //写到服务器 --- 网络中的流
        OutputStream os = socket.getOutputStream();
        BufferedOutputStream bos = new BufferedOutputStream(os);

        int b;
        while((b = bis.read())!=-1){
            bos.write(b);//通过网络写到服务器中
        }
        bos.flush();
        //给服务器一个结束标记,告诉服务器文件已经传输完毕
        socket.shutdownOutput();


        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        String line;
        while((line = br.readLine()) !=null){
            System.out.println(line);
        }
        bis.close();
        socket.close();


    }
}

package com.itheima.socketdemo8;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class ServerDemo {
    public static void main(String[] args) throws IOException {
        ServerSocket ss = new ServerSocket(10000);

        Socket accept = ss.accept();

        //网络中的流,从客户端读取数据的
        BufferedInputStream bis = new BufferedInputStream(accept.getInputStream());
        //本地的IO流,把数据写到本地中,实现永久化存储
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("socketmodule\\ServerDir\\copy.jpg"));

        int b;
        while((b = bis.read()) !=-1){
            bos.write(b);
        }
        //将字节输入流FileInputStream   转成     字符输入流  Fliereader

        //通过转换流
        InputStreamReader inputStreamReader = new InputStreamReader(accept.getInputStream());

        //通过缓冲输入字符流
        BufferedReader br = new BufferedReader(inputStreamReader);


        OutputStreamWriter outputStreamWriter = new OutputStreamWriter(accept.getOutputStream());
        BufferedWriter bw = new BufferedWriter(outputStreamWriter);
        bw.write("上传成功");
        bw.newLine();
        bw.flush();

        bos.close();
        accept.close();
        ss.close();


    }
}

这些优化看黑马程序员代码

13 日志(就是一些信息日记，替代输出语句，进行一些信息记录)

13.1 日志基础

12.2 Logback(框架，jar包)

12.3 日志级别

13 枚举

14 类加载器

类的字节码加载到内存，用到的时候才加载到内存，不用的时候不加载。

14.1 类字节码文件加载到内存

14.2 类加载器的分类

15 反射（获取类对象，对象属性，对象方法）

简单5分钟学会
两步：
（1）先获取类对象
（2）再获取对象的属性、或构造方法、或对象方法
本身属性、构造方法、对象方法也是对象，就是一个引用，获取到了可以直接用

15.1 获取类对象

15.2 获取对象的构造方法

15.3 根据对象的构造方法获取类对象

15.4 获取对象属性（Field）并赋值，可以给一个对象的属性赋值

15.5 获取成员方法并运行

16 注解（对文档的说明）

16.1 JDK内置的注解3个

16.2 自定义注解

16.3 元注解

16.4 注解的使用（后面好好看看）

16.5 单元测试