面向对象Java期末复习速成

明天就考试了，今天一波大复习，持续更新中。。。

JAVA核心知识点归纳

编程基础

一、基础知识

1. 标识符

   Java的标识符是赋予变量、类或方法的名称。简单理解就是自己起的名字。

   规则：1. 字母、下划线(_)、美元($)开头

   ​ 2. 字母、下划线(_)、美元($)开头、数字组成

   ​ 3. 区分大小写、无长度限制、不能使用关键字

2. 数据类型

   • 基本(简单)数据类型

     数值型：整数类型(byte、short、int、long)、浮点类型(float、double)

     字符型： ‘ ’（Java采用Unicode编码国际标准）

     布尔型：true、false

     数据类型转换：(int)、Math.round()、Integer.parseInt()

   • 复合(引用)数据类型

     类、接口、数组

3. 变量和赋值

   要特别注意作用域

4. 运算符和表达式

   • 基本赋值运算符 =

   • 算术运算符 + - * /

   • 关系运算 >、 >=、 < 、<= 、== 、!=

     运算结果是布尔值

   • 布尔运算 &&、 || 、！

     &&（短路与）左边为假，整个为假，右边就不进行操作

     ||（短路或）左边真，整个为真，右边就不进行操作

     运算结果是布尔值

   • 位运算（整数类型） >>、 << 、>>>、 & 、|、 ^ 、~

   • 条件运算 exp ? value1 : value2

     (exp为真吗？真就执行value1，假就执行value2)

   • 复合赋值运算 +=、-=、*=、=、%=、<<=、&=

5. 字符串

   区别于字符，字符串使用 “ ” ,字符使用 ’ '

6. if语句

   if else、if elseif elseif else

7. switch语句

   case：case： break；default；

8. for循环

   for（初始化表达式 ; 循环条件表达式(布尔类型) ; 循环后操作表达式 ）

9. 增强for循环

   访问整个数组+读取数组中的元素(不修改)+不需要使用下标进行处理

   格式：for(参数一 :参数二) { 执行语句 }

   参数一：定义一个变量存放数组里的元素（例如 int i）

   参数二：需要遍历的数组名

   执行语句里面要输出每个数据元素就直接 sout（ i + “ ”）

10. while、dowhile

11. break：跳出整个大循环

12. continue：跳出当前这一次循环

二、方法

• 定义方法

  明确两点：1、传入的参数类型 2、方法返回的数据类型

• 调用方法

• 递归方法

• 方法的重载：简单理解就是方法名相同，但传入的参数的类型或者个数不同

• 方法的重写：方法名相同，方法体不同

三、数组

• 数组的申明：

​ 静态初始化：枚举

​ 动态初始化：申明引用空间+分配空间+赋初值

​ int[] a = new int[10];

• 多维数组

  静态：int[][] [][] [] [] a={(1,2),(2,3),(3,4)}

  动态：

  int[ ] [ ] a=new int[2] [3];

  a[0] [0] =1;

面向对象

一、类和对象

UML：类名+属性+方法(**+public、-private、#**protected)

1. 访问权限修饰符：

   public：当申明成员时，所有其他类都可以访问到

   private：当修饰成员时，只能被该类里面访问到

   protected：当前包和其继承得到的子类(包内外都可以)

   默认：同一个包内就可以访问到

2. 对象

   成员变量：类内都可以访问到

   局部变量：代码块内或者某一个具体的方法内

   （通常是要用一个局部变量里的内容，然后发现他是局部的，这时候作用的范围就要放大到方法外面，这样就可以获取到了。）

3. 构造方法（可重载）

   简单理解重载和重写：重载是方法传入的参数不同，重写是方法的内容（即方法体）不同。

   三种方式：带参（需要什么成员变量就构造传入什么）、不带参、默认（不带参）！！

   **！！！**注意：如果定义了有参的构造方法，系统就不会默认生成无参的构造方法，

   如果需要，需要自己在定义一个无参的

4. this关键字

   主要在构造方法里面使用，使用到**this.**就是指代的这个类最上面定义的成员变量。将构造方法里面传入的数据，传给成员变量

5. static修饰符

​ 简单理解就是用了static修饰，系统就自动初始化分配空间，就可以直接使用，不实例化也可以直接用。

高级面向对象

一、GUI

二、异常处理

三、集合类

ArrayList

​ add()方法传入的是引用的地址

TreeSet

​ add()

HashMap

​ put（”键“，“值”）

迭代器Iterator

Iterator<对象> it = 对象.iterator();
		while(it.hasNext()) {
			对象类型 temp = it.next();
			System.out.println(temp.print());
		}

四、输入输出流

五、多线程

六、网络编程

InetAddress.getLocalHost()、URL、Socket

TCP

原理就是new一个服务器，一直处于监听，然后通过输入流来读信息，通过输出流来发送信息，多人聊天就用多线程将收发信息run方法封装起来。

客户端就直接连接服务器，IP+端口号一致即可，也是通过输入输出流来收发信息。

这部分内容静心理解一遍之后，直接沉下心默三遍！

Server端

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;

public class multiServer {
    //定义一个集合类用来存放客户端
    static ArrayList<Socket> array = new ArrayList<>();
    
    public static void main(String[] args) {
        System.out.println("==============等待连接===========");
        try {
            ServerSocket ss = new ServerSocket(9001);
            while (true) {
                //让服务器一直处于监听状态，一直允许客户端连接，
                Socket socket = ss.accept();
                System.out.println( socket.getInetAddress()+ "已连接");
                //每连接一次就add一次进去
                array.add(socket);
                //为当前连接进来的socket创建一个服务器端的线程，专门用来接收和发送消息
                receive r1 = new receive(socket);
                r1.start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    static class receive extends Thread {
        Socket socket;
        public receive(Socket socket) {
            this.socket = socket;
        }
        @Override
        public void run() {
            super.run();
            try {
                while (true) { //持续接收来自客户端发过来的信息
                    InputStream inputStream = socket.getInputStream();//用socket获取来的输入流作为创建输入流
                    //利用byte来存储从客户端获取到的数据
                    byte[] bytes = new byte[1024];
                    inputStream.read(bytes);
                    String s = new String(bytes);//将数组里面的数据放入字符串
                    //遍历集合里面的每一个Socket对象，分别创建输出流，并发送客户端发来的信息
                    for (int i = 0; i < array.size(); i++) {
                        OutputStream outputStream = array.get(i).getOutputStream();
                        outputStream.write(s.getBytes());
                        outputStream.flush();
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

Client

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.util.Scanner;


public class multiClient {
    public static void main(String[] args) {
        try {
            Socket soc = new Socket("192.168.3.8", 9001);
            System.out.println("请输入要发送的信息：");
            Scanner sc = new Scanner(System.in);
            String str = sc.nextLine();

            OutputStream outputStream = soc.getOutputStream();
            outputStream.write(str.getBytes());
            outputStream.flush();

            while (true) {
                InputStream inputStream = soc.getInputStream();
                byte[] bytes = new byte[1024];
                inputStream.read(bytes);
                String s = new String(bytes);
                System.out.println("收到来自服务器发送的消息：" + s);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

UDP

使用DatagramSocket和DatagramPacket

通过send()和receive()方法来发送和接收信息