当我们走出校园，步入社会，必须得找工作，那么作为it小白你必须拥有过硬的基础应用知识，才能慢慢的适应工作的节奏，以下内容则都是基础中的基础，需要全部进行掌握，因为这里可能有你面试时需要回答的面试题。
一：equals方法
这个方法的返回值是Boolean型，是通过地址来对对象进行判断
System.out.println(Math.ceil(-11.2));
String num1 = "hello world";
String num2 = "hello world";
String num3 = "hello";
//在Java中equals是通过对象的地址值来进行比较的 = 则是通过值来进行
int address = System.identityHashCode(num1);
int address1 = System.identityHashCode(num2);
int address2 = System.identityHashCode(num3);
System.out.println("对象的地址："+address);
System.out.println("对象1的地址："+address1);
System.out.println("对象2的地址："+address2);
System.out.println("判断对象与对象1是否相等"+num1.equals(num2));
System.out.println("判断对象与对象2是否相等"+num1.equals(num3));注意:通过System.identityHashCode()来获取对象的地址值
结果进行输出：
那么符号=(等号）呢？
等号则是通过对属性值的比较来判断是否相等。
二：StringBuilder类与String的区别
String是字符串，它的内容是不可变的，但是StringBuilder封装的内容则是将内容放在一个容器中，可以对容器中的内容进行修改，也就是可变的。
将对象封装在StringBuilder类中可以对对象进行各种的操作：反转.添加.删除等操作，可以进入源代码类中对类中的方法进行了解package java.lang包下面
功能案例：反转（功能很多，可以通过源码进行了解)
String str = "abcd"; StringBuilder stringBuilder = new StringBuilder(str); String reverse = stringBuilder.reverse().toString(); System.out.println(reverse);控制台输出：
三：String创建对象
首先咱们先了解一下Java中堆栈的区别
在Java语言中，栈一般存放方法和基本类型，这里要注意一下，String并不是一个基本的类型，堆一般存放着对象和数组。
String创建对象通常情况下分为两种
String str = "abcd";
String str1 = new String("abcd");这两种创建对象的方式拥有很大区别
String str = "abcd";区别一：创建的对象存在堆内存中，内容只会有一份，意思就是出现相同的内容，在堆内存中，并不会增加，会用已有的这一个。
String str1 = new String("abcd");而这种创建对象的方法，则是每一次都会new一个对象在堆内存中。
这种区别可以这样的理解：方法二实现的流程是先去常量池中创建对象，然后在通过new方法去创建对象，而方法一则是因为在如果常量池中，已经有了这个对象，那么则不会进行创建对象这一步骤，如果没有则是实现方法二的执行流程
new String("a") + new String("b")这行代码执行会创建几个对象
1：中间有一个＋这是属于拼接字符串，会创建一个StringBuilderu对象
2：创建一个String对象 new String("a")
3：会在常量池中放一个a对象
4：创建一个String对象 new String("b")
5：会在常量池中放一个b对象
6：调用StringBuilder类中的tostring对象输出ab
四：抽象类与普通类的主要区别
1：修饰符：必须通过 abstract 关键字来进行修饰。
公式1：（修饰类）修饰符abstract class 类名{}
公式2：（修饰成员方法）修饰符 abstract 返回类型 方法名（）
2：抽象类不能被实例化，只能通过创建子类对象。（抽象的意思就是不具体，所以不能 new ）
3：抽象类子类的两个选择：
一：重写父类的所有抽象方法
二：把类定义为抽象类抽象类成员的特点:
- 成员变量：
可以有普通的成员变量
也可以有成员常量- 成员方法：
可以有普通方法，也可以有抽象方法
可以既可以有抽象方法， 也可以有非抽象方法
有构造方法 并且构造方法可以重载
五：什么是接口？
1：语法格式：[修饰符] interface 接口名 [ extends 父接口名列表]{}
注意：被[ ] 定义的都是可选的，有或者没有都可以。
2：类和接口是实现关系，用implements 类表示
class 类名 implements 接口名
注意： 接口修饰的成员方法中都有默认的修饰方法 public abstract
想要在接口的实现类中的方法实现，必须出现方法重写
接口继承关系的特点：
接口与类是实现的关系接口与接口之间的关系：继承关系 ，可以是单继承或者是多继承关系（格式 接口 extends接口1，接口2…
继承与实现的区别
1:继承是体现 is a的关系 ，在父类中定义共性的内容
2:实现体现的是like a的关系，接口中定义扩展功能
举例介绍：在动物类中 马 狗 猪 猴子都有名字 都睡觉 都吃饭 这是共性内容，把这些定义在父类中。在日后，猴子有了爬树的功能，而这就是定义在接口中。
接口的成员特点
1：成员变量的特点：接口没有成员变量，只有公有的.静态的常量
接口会有默认值（public static final)常量名=常量值
2：接口成员方法特点
（JDK7及以前）公有的，抽象方法：
public sbstract 返回值类型 方法名（）；
（JDK8以后）可以有默认方法和静态方法：
默认 public default 返回值类型 方法名（）{}
静态 static 返回值类型 方法名（）{}
（JDK9以后）可以有私有方法：
private 返回值类型 方法名（）{}
3：接口构造方法的特点：
接口不能实例化，也没有初始化的成员所以没有构造方法
更多的关于接口和抽象类的内容可以去界面抽象类，接口基础讲解
六：IO流
I：input指的是对硬盘读操作
O：output指的是对硬盘的写操作
IO流的分类
第一种分类：则是上面介绍的输入(I)输出(O)流:读写操作
第二种分类：根据读取数据的方式不同
字节流：指的是读取数据的多少，字节流每一次读取一个字节也就是8个二进制位，但是这种流读取的文件是万能的，就是什么类型的文件都可以读取，例如：文本文件，图片，声音文件，视频文件等。
读取demo.txt中的文字内容，文档中是以下的内容：m不想睡醒的梦
第一次读取：“a”
第二次读取：文字”不“得前8个二进制位
第三次读取：文字”不“得后8个二进制位
字符流:一次读取只能读取一个字符，"a"是一个字符，"不"也是一个字符，但是它得读取文件类型则不是万能的了，只能读取普通文本文件（.java、.ini、.py .txt)，不能读取图片视频声音等文件。
读取demo.txt中的文字内容，文档中是以下的内容：m不想睡醒的梦
第一次读取：“a”
第二次读取：”不"
第三次读取："想"
FileInputStream
“万能”读取数据流
这里要读取的文件demo1.txt内容是:abcdefghc
案例：读取文本内容
方法一：
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class Fileinputstream {
public static void main(String[] args) throws IOException {
FileInputStream file = null;
try {
file = new FileInputStream("C:/Users/lenovo/Desktop/demo1.txt");
// System.out.println(file.read()); //read()方法返回的则是文件第一个字节的ACILL值
byte[] bytes = new byte[4]; //通过数组的方式去读取数据，数组的长度则实现每一次读取字节的长度
int readcount = 0;
// file.read(bytes);
// for(byte y : bytes){
// System.out.println(y); //
// }
while ((readcount = file.read(bytes)) != -1){
System.out.println(new String(bytes,0,readcount)); //通过使用平台的默认字符集解码指定的 byte 子数组，构造一个新的 String。
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
finally {
if (file !=null){
file.close();
}
}
}
}
输出结果：一次只读取数组长度的内容模块
方法二：
import java.io.FileInputStream;
import java.io.IOException;
public class Fileinputstram_02 {
public static void main(String[] args) throws IOException {
FileInputStream file = null;
try {
file = new FileInputStream("C:/Users/lenovo/Desktop/demo1.txt");
// System.out.println("查看读取该文件的总字节数:"+file.available()); //通俗的来讲就是这个文件在内存中占了多少个字节
// int num1=file.read();
// System.out.println(num1);
// System.out.println("查看还有多少个字节没有读:"+file.available());
byte[] bytes = new byte[file.available()];
file.read(bytes);
System.out.println(new String(bytes)); //控制台进行输出：abdefgh
//跳过几个字节的内容再开始读取内容
file.skip(1);
System.out.println(file.read()); //控制台进行输出：98 跳过97这一个字节
} catch (Exception exception) {
exception.printStackTrace();
}
finally {
if(file != null){
file.close();
}
}
}
}
七：Socket类与ServerSocket
Socket类实现的是不同计算机进行字节流的传递，可以这样的理解Socket实现的是不同计算机通过端口号实现内容的传递，
ServerSocket则是在客户/服务器通信模式中，服务器通过创建监听端口的ServerSocket，它负责接收客户端发送的连接请求，生成服务器与客户端连接需要的Socket。
案例：通过代码简单的模拟客户端与服务器信息的交互
客户端代码(附带详细的解释)
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.Socket;
import java.net.UnknownHostException;
public class Socket_client {
//服务器的端口号和ip地址
public static final int port =8080;
public static final String host = "localhost";
public static void main(String[] args) throws IOException {
System.out.println("client is starting.....");
while(true) {
Socket socket = null;
try {
//连接服务器
socket = new Socket(host, port);
//读取服务器所传递出来的信息
BufferedReader input = new BufferedReader(new InputStreamReader(socket.getInputStream()));
//向服务器传递信息
PrintStream out = new PrintStream(socket.getOutputStream());
System.out.println("请输入 \t");
//将客户端输入的数据发送到服务器中
String str = new BufferedReader(new InputStreamReader(System.in)).readLine();
out.println(str);
//接收服务器所传递输出来的数据，并打印出来
String ret = input.readLine();
System.out.println("服务器返回的数据是：" + ret);
//判断是否关闭此次连接
if ("ok".equals(ret)) {
System.out.println("客户端关闭连接");
Thread.sleep(500);
break;
}
out.close();
input.close();
} catch (Exception e) {
System.out.println("客户端异常:" + e.getMessage());
} finally {
if (socket != null) {
socket.close();
}
}
}
}
}
服务器代码(附带详细的解释)
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
public class Server {
public static final int port = 8080;//监听的端口号
public static void main(String[] args) {
System.out.println("Server is starting...\n");
Server server = new Server();
server.init();
}
public void init() {
try {
//创建一个ServerSocket，这里可以指定连接请求的队列长度
//new ServerSocket(port,3);意味着当队列中有3个连接请求是，如果Client再请求连接，就会被Server拒绝
ServerSocket serverSocket = new ServerSocket(port);
while (true) {
//从请求队列中取出一个连接
Socket client = serverSocket.accept();
// 处理这次连接
new HandlerThread(client);
}
} catch (Exception e) {
System.out.println("服务器异常: " + e.getMessage());
}
}
//通过线程来实现内容的接收和发送
private class HandlerThread implements Runnable {
private Socket socket;
public HandlerThread(Socket client) {
socket = client;
new Thread(this).start();
}
public void run() {
try {
// 读取客户端数据
BufferedReader input = new BufferedReader(new InputStreamReader(socket.getInputStream()));
String clientInputStr = input.readLine();//这里要注意和客户端输出流的写方法对应,否则会抛 EOFException
// 处理客户端数据
System.out.println("客户端发过来的内容:" + clientInputStr);
// 向客户端回复信息
PrintStream out = new PrintStream(socket.getOutputStream());
System.out.print("请输入:\t");
// 发送键盘输入的一行
String s = new BufferedReader(new InputStreamReader(System.in)).readLine();
out.println(s);
out.close();
input.close();
} catch (Exception e) {
System.out.println("服务器 run 异常: " + e.getMessage());
} finally {
if (socket != null) {
try {
socket.close();
} catch (Exception e) {
socket = null;
System.out.println("服务端 finally 异常:" + e.getMessage());
}
}
}
}
}
}结果测试
客户端向服务器传递数据1
服务器接收到客户端传递的数据，并回复一个2
客户端接收到数据2，并回复ok，结束此次连接
服务器向客户端传递ok表示连接的结束
通信成功
