Java复习

第一章： Java开发入门

Java语言是一种面向对象的语言
Java语言的特点有：面向对象，跨平台性，安全性，支持多线程和分布式
将.java源文件编译为.class文件的命令是： JavaC
Java程序的运行环境为： JRE
简述Java语言的特点

简单性，面向对象，安全性，跨平台性，支持多线程，分布性
简述Java的运行机制

Java程序运行时，必须经过编译和运行两个步骤，首先将后缀名为 .java的源文件进行编译，生成后缀名为 .class 的字节码文件，然后Java虚拟机将字节码文件进行解释执行，并将结果运行出来

编写一个Hello World 程序

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

第二章： Java编程基础

Java中的常量有：整形常量，浮点数常量，字符常量，字符串常来那个，布尔常量， null常量
进制转换（还未看）
变量的数据类型
变量的自动类型转换
1. 自动类型转换 (小的往大的转换)
2. 强制类型转换
Java中的运算符：算术运算符，赋值运算符，比较运算符，逻辑运算符
流程控制语句
数组的基本元素：数组名称，数组元素，元素索引，数据类型
Java程序代码必须放在一个类中，类使用 Class 关键词定义
Java中的注释有3类，分别是单行注释，多行注释，文档注释
int类型所占的存储空间为： 4个字节
用于比较两个整数是否相等的运算符是： ==
数组是一个容器，存储到数组中的每个元素都有自己的自动编号，最小值为：0
String 不属于基本数据类型
简述Java 中的8中基本数据类型，并说明每种数据类型所占的存储空间大小

|数据类型|所占空间大小|
| ————————————| ——————————————-|
|byte 字节型|一个字节|
|short 短整型|2个字节|
|int 整形|4 个字节|
|long 长整型|8 个字节|
|float 单精度浮点型|4 个字节|
|double 双精度浮点型|8 个字节|
|char 字符型|2 个字节|
|booblean 型表示逻辑值|true , false 分别占一个字节|
简述跳转语句 break 与 continue 的作用和区别

在Switch 条件语句和循环语句中都可以使用break语句，当它出现在Switch 条件语句中时，作用是终止某个case 并跳出swtich 结构，当它出现在循环语句中，作用是跳出循环语句，执行循环后面的代码， continue 语句用在循环语句中，它的作用是终止本次循环，并执行下一次循环

编程题

编写程序，计算 1 + 3 + ….+ 99 的值，要求如下：

使用循环语句实现1\x7e99 的遍历

在遍历过程中，通过条件判断当前的数是否为奇数，如果是就累加，否则不加

public class ForDemo {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 1; i < 100; i++) {
            if (i % 2 != 0) {
                sum += i;
            }
            System.out.println(sum);
        }
    }
}

使用do….while 循环语句计算正数5的阶乘

public class DoWhileDemo {
    public static void main(String[] args) {
        int i = 1;
        long sum = 1;
        do {
            sum *= i;
            i ++;
        } while (i <= 5);
            System.out.println(sum);
    }
}

第三章：面向对象(上)

面向对象的思想：封装性，继承性，多态性

类的定义

class 类名 {
	成员变量;
	成员方法;
}

访问控制权限
一个类可以定义多个构造方法，只要每个构造方法的参数类型或参数个数不同，即可实现重载
封装就是隐藏对象的属性和实现细节，仅对外提供公有的方法
对于声明为 private , protected 及public 的类成员在类外部，都不能访问
简答题：
1. 简述你对面向对象的三大特征的理解
  
  面向对象的特点主要可以概括为封装性，继承性和多态性
  
  其中封装是面向对象核心思想，将对象的属性和行为封装起来，不需要让外界指导具体实现细节，这就是封装的思想
  
  继承性主要面熟的是类与类之间的关系，通过继承可以在无需重载编写原有类的情况下，对原有类的功能进行扩展
  
  多态性指的是在程序中允许出现重名现象，它指在一个类中定义的
  
  属性和方法被其他类继承后，他们可以具有不同的数据类型或表现出不同的行为，这使得同一个属性和方法在不同的类中具有不同的语义
2. 简述构造方法的特点
  1. 构造方法与类名相同
  2. 在构造方法名的前面没有返回值类型的声明
  3. 在构造方法中不能使用return 语句返回一个值

编程题：

某公司正在进行招聘工作，被招聘人员需要填写个人信息，编写个人简历的封装类Resume , 并编写测试类进行测试

package com.north.chapter03;

public class Resume {
    private String name;
    private String sex;
    private int age;

    public Resume() {

    }

    public Resume(String name, String sex, int age) {
        this.name = name;
        this.sex = sex;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

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

    public void introdece() {
        System.out.println("姓名：" + this.getName());
        System.out.println("性别：" + this.getSex());
        System.out.println("年龄:" + this.getAge());
    }
}

package com.north.chapter03;

public class Application {
    public static void main(String[] args) {
        Resume resume = new Resume("李四" , "男" , 20);
        resume.introdece();
    }
}

第四章：面向对象(下)

一个类如果要实现一个接口，那么它就需要重写接口中定义的全部方法，否则该类就必须定义成抽象类
接口中定义的变量默认是 public static final 型，且必须赋初值
java中的 instanceof 关键字可以判断一个对象是否为某个类(或接口) 的实例
简答题
1. 简述java中继承的概念以及使用继承的好处
  
  概念：在java中，类的继承是指在一个现有类的基础上构建一个新的类，构建出来的新类被作子类，现有类被作为父类，子类会自动拥有父类所有可继承的属性和方法。
  
  好处：继承性主要描述的是类与类之间的关系，通过继承，可以无需重新编写原有类的情况下，对原有类的功能进行使用和扩展
2. 简述多态的作用
  
  java中的多态性能够提高代码的灵活性，可维护性和可扩展性，是的程序设计更符合面向对象的思想
3. 简述接口和抽象类的区别
  1. 接口只能定义抽象方法，而抽象类可以定义抽象方法和非抽象方法
  2. 类可以实现多个接口，但只能继承一个抽象类
  3. 接口中的成员默认是 public , 抽象类中的成员可以有多种访问权限
  4. 抽象类可以有构造方法，而接口不能有构造方法

‍

第五章：异常

Java 中的异常是指Java程序在运行时可能出现的错误或非正常情况
Throwable 类的继承体系图
RuntimeException 类及其子类用于表示运行时异常
异常分为两种，分别是运行时异常和编译时异常
自定义异常需要继承
Exception 类
简答题
1. 写出处理异常的5个关键字
  
  try , catch , finally , throw , throws
2. 简述 try .. catch 语句的异常处理流程并画出流程图
  
  程序通过try语句捕获可能出现的异常，如果try语句没有捕获到异常，则直接跳出try…catch语句块执行其他程序；如果在try语句中捕获到了异常，则程序会自动跳转到catch语句中找到匹配的异常类型进行相应的处理。如果try语句捕获到的异常与catch语句例的异常匹配，则先执行catch中的语句，最后执行其他程序语句。
3. 简述处理编译时异常的两种方式
  1. 使用try … catch 语句对异常进行捕获处理
  2. 使用throws 关键字声明抛出异常，调用者对异常进行处理

第六章：Java API

API 指的是应用程序变成接口
在Java中定义3个类，用来封装对字符串的操作，分别是 String , StringBuffer , StringBuilder
java中用来获取String字符串长度的方法是： length();
Java中用于将日期格式或为字符串的类是： DateFormat
Java中用于产生随机数的类位于 java.util包中的Random
Pattern 类用于创建一个正则表达式，也可以说创建一个匹配模式，它的构造方法是私有的，不可以直接创建正则表达式
简答题：
1. 简述 String , StringBuffer 和 StringBuilder 三者的区别
  
  String类表示的字符串是常量，一旦创建后，内容和长度都是无法改变的。而StringBuilder和StringBuffer表示字符容器，其内容和长度可以随时修改。在操作字符串时，如果该字符串仅用于表示数据类型，则使用String类即可，但是如果需要对字符串中的字符进行增删操作，则使用StringBuffer与StringBuilder类。如果有大量字符串拼接操作，不要求线程安全的情况下，采用StringBuilder更高效。相反如果需要线程安全则需要使用StringBuffer。
2. 简述8中基本数据类型及其对应的包装类
  
  |基本数据类型|对应的包装类|
  | ————-| —————-|
  |byte|Byte|
  |char|Character|
  |int|Integer|
  |short|Short|
  |long|Long|
  |float|Float|
  |double|Double|
  |boolean|Boolean|

编程题

每次随机生成10个0~100的随机正整数

public class Demo {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            System.out.println(new Random().nextInt(100));
        }
    }
}

计算从今天算起100天以后是几月几日，并格式化成xxxx年x月x日的形式打印出来

提示：

调用Calendar类的add()方法计算100天以后得日期
调用Calendar类的getTime()方法返回Date类型的对象

教师用FULL格式的DateFormat对象，调用format()方法格式化Date对象

public class Test {
    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.DATE , 100);
        Date date = calendar.getTime();
        DateFormat format = DateFormat.getDateInstance(DateFormat.FULL);
        String string = format.format(date);
        System.out.println(string);
    }
}

第七章：集合

集合的核心继承体系图
Collection 是所有单列集合的父接口
使用Iterator 遍历集合时，首先需要调用 hashNext() 方法区判断是否存在下一个元素，若存在下一个元素，则调用 next() 方法取出该元素
1
2
3
while (iterator.hasNext()) {
Object next = iterator.next();
}
如果要对TreeSet集合中的对象进行排序，必须实现 Comparable 接口
ArrayList 内部封装了一个长度可变的数组
ArrayList 集合查询元素的速度很快，但是增删改查效率较低
List 集合的特点是元素有序并且可重复
Set集合的她点事元素无序并且不可重复
简答题
1. 简述集合List ， Set 和Map 的区别
  
  List的特点是元素有序、可重复。List接口的主要实现类有ArrayList和LinkedList。
  
  Set的特点是元素无序、不可重复。Set接口的主要实现类有HashSet和TreeSet。Map的特点是存储的元素是键(Key)、值(Value)映射关系，元素都是成对出现的。Map接口的主要实现类有HashMap和TreeMap。
2. 为什么ArrayList 的增删改查操作比较慢，而查找操作比较快
  
  由于ArrayList集合的底层是使用一个数组来保存元素，在增加或删除指定位置的元素时，会导致创建新的数组，效率比较低，因此不适合做大量的增删操作。但这种数组的结构允许程序通过索引的方式来访问元素，因此使用ArrayList集合查找元素很便捷。

编程题

编写程序，向ArmsList集合中添加元素，然后遍历并输出这些元素。

public class Example {
    public static void main(String[] args) {
        ArrayList list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("a");
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            Object next = iterator.next();
            System.out.println(next);
        }
    }
}

按照下列要求编写程序

写一个Student类，包含name和age属性，提供有参构造方法。
在Snudent 类中，重写 toString()方法，输出age和name的值。
在Student类中，重写hashCode()和equals()方法。
1. .hshCode()的返回值是name的哈希值与age的和。
2. .equals()判断对象的name和age是否相同，相同则返回true，不同则返回false。

编写一个测试类，创建一个HashSet＜Student＞对象hs，向hs中添加多个sat对象，假设有两个Student对象相等。输出HashSet集合，观察Student对象是否添加成功。

Student类

             package com.north.chapter07;
             
             import java.util.*;
             
             
             public class Student {
             
                 private int age;
             
                 private String name;
             
             
                 public Student(int age, String name) {
                     this.age = age;
                     this.name = name;
             
                 }
             
             
                 public String toString() {
                     return age + ":" + name;
             
                 }
             
             
                 public int hashCode() {
                     return name.hashCode() + age;
             
                 }
             
             
                 public boolean equals(Object obj) {
                     if (this == obj)
                         return true;
                     if (!(obj instanceof Student))
                         return false;
                     Student stu = (Student) obj;
                     return this.name.equals(stu.name) && this.age == stu.age;
             
                 }
             
             }
             

## 第八章： 泛型

1. 使用泛型的好处

    > 1. 提高类型的安全性
    > 2. 消除强制类型转换
    > 3. 提高代码的复用性
    > 4. 拥有更高的运行效率
    >
2. 泛型类

    ```java
    public class Student<T> {

    }

泛型接口
1
2
3
public interface North<T> {

}

泛型方法

1
2
3

访问权限修饰符 static final <类型形象> 返回值类型 方法名 (形参列表) {

}

泛型使用 ? 表示参数化
泛型可以用在类，接口和方法的定义中，分别称为泛型类，泛型接口和泛型方法
在java程序中，经常会有参数类型或返回值类型不确定的方法，这种方法在java中统称为泛型方法
泛型接口的实现类有两种定义方式，一种是直接接口中明确给出泛型类型，另一种是直接在实现后声明泛型
在实际应用中，只有泛型类被使用时，该类所属的类型才能确定
简答题
1. 简述泛型的有
  1. 提高类型的安全性。
    
    泛型的主要目标是提高Java程序的类型安全性，即可以通过泛型定义对变量类型进行限制，在对变量类型限制之后编译器可以更好的进行类型验证。
  2. 避免强制类型转换
    
    使用泛型的另一个好处是避免源代码中的许多强制类型转换。这使得代码可读性更高，并且减少出错机会。尽管减少强制类型转换可以降低使用泛型类代码的复杂度，但是声明泛型变量会带来相应的复杂操作。

编程题

按照下列提示编写一个泛型接口以及其实现类

创建泛型接口Generic,并创建抽象方法get(T t)

1
2
3

public interface Generic<T> {
      void get(T t);
}

创建实现类GenericImpl , 并实现get(T t)方法

public class GenericeImple<T> implements Generic<T>  {
    @Override
    public void get(T t) {
        System.out.println("Received: " + t.toString());
    }
}

第九章：反射

反射机制的优点是可以实现动态创建对象和编译
如果通过Class类实例化其他类的对象，则可以使用 newInstance() 方法，但是必须保证被实例化的类中存在一个无参构造方法
通过反射可以得到一个类中的所有方法，需要用到 java.lang.reflect 包中的 Method 类
在反射操作中，通过 getDeclaredFields() 方法可以去的本类中的全部属性
要取得一个类中的全部方法，可以使用Class 类中的 getMethods() 方法
简答题
1. 简述反射机制
  
  Java的反射（reflection）机制是指在程序的运行状态中，可以构造任意一个类的对象，可以得到任意一个对象所属的类的信息，可以调用任意一个类的成员变量和方法，可以获取任意一个对象的属性和方法。这种动态获取程序信息以及动态调用对象的功能称为Java语言的反射机制
2. 简述实例化Class 对象的三种方式
  
  （1）根据类名获取：类名.class；
  
  （2）根据对象获取：对象.getClass()；
  
  （3）根据全限定类名获取：Class.forName(“全限定类名”)。

第十章： I/O流

Java中的IO流按照传输数据的不同可分为字节流和字符流
java.io 包中可以用于从文件直接读取字符的类是 Reader
IO系统提供了两个带缓冲的字节流，分别是 BufferedInputStream 和 BufferedOutputStream
在JDK中提供了两个可将字节流转换为字符流的类分别是： InputStreamReader 和 OutputStreamWriter
java.io.FileOutputStream 是 OutputStream 的子类，它是操作文件的字节输出流
转换流实现了字节流和字符流的相互转换
简答题
1. 简述字符流与字节流的区别
  
  字节流的两个基类是InputStream和OutputStream，字符流的两个基类是Reader和Writer，它们都是Object类的直接子类，字节流是处理以8位字节为基本单位的字节流类；Reader和Writer类是专门处理16位字节的字符流类。
2. 简述InputStreamReader 类与 OutputStreamWriter类的作用
  
  InputStreamReader是Reader的子类，它可以将一个字节输入流转换成字符输入流，方便直接读取字符。OutputStreamWriter是Writer的子类，它可以将一个字节输出流转换成字符输出流，方便直接写入字符。

第十一章：JDBC

JDBC 驱动程序管理器专门负责注册特定的JDBC驱动程序，主要通过 java.sql.DriverManager 类实现的
在编写JDBC应用程序时，必须要把制定数据库驱动程序或类库加载到 classpath 中
PreparedStatement 是Statement 的子接口，用于执行预编译的SQL语句
创建Statement 对象的作用是：执行SQL语句
简答题：
1. 简述JDBC编程的6个开发记录
  1. 加载并注册数据库驱动；
  2. 通过DriverManager获取数据库连接；
  3. 通过Connection对象获取Statement对象；
  4. 使用Statement执行SQL语句；
  5. 操作ResultSet结果集；
  6. 回收数据库资源。
2. 什么是预编译
  
  所谓预编译,就是说当相同的SQL语句再次执行时,数据库只需使用缓冲区中的数据,而不需要对SQL语句再次编译,从而有效提高数据的访问效率。

第十二章：多线程

实现多线程的两种方式是继承 Thread 和实现 Runnable 接口
线程的整个生命周期分为5个阶段，分别是新建状态，就绪状态，运行状态，堵塞状态和死亡状态
在Thread 类中，提供了 start() 方法用于启动新线程
执行 sleep() 方法，可以让线程在规定的时间内休眠
同步代码块使用 synchronized 关键字修饰
简答题：
1. 简述创建多线程的两种方式
  一种是继承java.lang包下的Thread类，覆写Thread类的run()方法，在run()方法中实现运行在线程上的代码。
  1
  2
  3
  new Thread() {
  public void run(){}
  }.start();
  另一种就是实现java.lang.Runnable接口，同样是在run()方法中实现运行在线程上的代码。
  1
  2
  3
  class MyThread implements Runnable{
  public void run(){}
  }
2. 简述同步代码块的作用
  
  同步代码块的作用是控制线程，保证同步代码块中只能有一个线程在运行，保证了多线程操作数据的安全性

编程题

编写一个多线程程序，模拟火车售票窗口的售票功能，创建线程1 和线程2 ，通过这两个线程共同售出100张票

public class TicketWindow implements Runnable{
    // 定义100张票
    private int num = 100;
    @Override
    public void run() {
        while (num > 0) {
            Thread th = Thread.currentThread();
            String th_name = th.getName();
            System.out.println(th_name + " 正在发售第 "  + num-- + " 张票" );
        }
    }
}


public class Application {
    public static void main(String[] args) {
        TicketWindow ticketWindow = new TicketWindow();
        new Thread(ticketWindow , "线程1").start();
        new Thread(ticketWindow , "线程2").start();
    }
}

第十三章：网络编程

基于TCP/IP的网络草考模型被分为4层，分别是链路层，网络层，运输层和应用层
在进行网络通信时，传输层可以采用TCP ，也可以采用UDP
在下载文件时，必须采用TCP
JDK提供了 DatagramSocket 类，该类可以发送和接受数据包
在JDK中提供了两个用于实现TCP程序的类，一个是 ServerSocket 类，用于表示服务端，另一个是Socket类，用于表示客户端
简答题
1. 简述TCP通信与UDP通信的主要区别
  
  UDP通信与TCP通信的区别在于，UDP中只有发送端和接收端，不区分客户端与服务器端，计算机之间可以任意地发送数据；而TCP通信是严格区分客户端与服务器端的，在通信时，必须先由客户端去连接服务器端才能实现通信，服务器端不可以主动连接客户端，并且服务器端程序需要事先启动，等待客户端的连接。
2. 简述TCP中服务器端与客户端的连接过程
  
  在TCP连接中必须要明确客户端与服务器端，由客户端向服务器端发出连接请求，每次连接的创建都需要经过“三次握手”。第一次握手，客户端向服务器端发出连接请求，等待服务器确认；第二次握手，服务器端向客户端回送一个响应，通知客户端收到了连接请求；第三次握手，客户端再次向服务器端发送确认信息，确认连接。