Java 2 实用教程第五版期末复习（部分）

---

题型分布

判断题15*1
选择题15*2
简答题 2*3
程序阅读题 3*5 难度微高
编程题 8 + 22 有泛型 ArrayList（一点点）

---

第一章

java是什么语言？

解释型语言；
面向对象程序设计语言；

java的特点

//课本
简单 
面向对象
平台无关
多线程
动态

简单性 
面向对象 
分布式 
健壮性 
安全性 
体系结构中立 
可移植性 
解释型 
高性能 
多线程 
动态性

java项目的组成

至多一个public类
必须且仅有一个main类

在命令行中执行一个java文件的过程

javac XXX.java //编译器
java XXX //解释器

---

第二章

标识符命名规则

由标识符的组成：26个英文字母（大、小写），数字，下划线，美元符号$
Java标识符严格区分大小写，长度无限制
标识符不能用数字开头
不要使用关键字和Java中的自带类名称做标识符

定义

用来标识类名、变量名、方法名、类型名、数组名、文件名的有效字符序列称为标识符。
注：不要和关键字混淆

命名方式

小驼峰命名法 变量名
大驼峰命名法 类名，函数名，属性，命名空间等
全大写命名法 定义常量等

常量定义

public class HelloWorld {
    // 静态常量
    public static final double PI = 3.14;
    // 声明成员常量
    final int y = 10;
    public static void main(String[] args) {
        // 声明局部常量
        final double x = 3.3;
    }
}

数组一维和二维的初始化

一维数组

//静态初始化方式
int[] a = new int[]{1,2,3}

//动态初始化
int[] a = new int[3];

//简化的静态初始化方式
int[] a = {1,2,3};

二维数组

//定义加初始化

//第一种：
        //int[][] arr1 = new int[][]{{1,2}, {2, 3}, {4, 5}};
        int[][] arr1 = {{1,2}, {2, 3}, {4, 5}};

//第二种
        int[][] arr2 = new int[4][3];

 //第三种
        int[][] arr3 = new int[4][];

---

第三章

自增、自减运算符

++i；
i++;
--i；
i--;

循环语句

while（条件表达式）{
//执行语句
}

do{
//执行语句
} while（条件表达式）;

for(初始化; 布尔表达式; 更新) {
//执行语句
}

判断语句

//if-else语句是最常用的判断语句，
//三种使用方式。
if-else语句

//switch后台面的表达式只支持byte char int short String(JDK1.7以上)。
switch语句

try、catch

try {
	//必须。检查是否有错误的代码块。
    tryCode - 尝试执行代码块 
}
catch(err) {				//err异常类名,必须(如果使用 catch)。指定局部变量应用的错误。该变量可以引用 Error 对象 (包含发生的错误信息)。如果异常通过 throw 语句创建 ， 该变量引用了为在throw语句中指定的对象
	//可选。如果 try 语句发生错误执行的代码块。如果 try 语句没发生错误该代码不会执行。
    catchCode - 捕获错误的代码块 
}

//可选
finally {
    finallyCode - 无论 try / catch 结果如何都会执行的代码块
}

break 和 continue 的区别

break

break：终止switch或者循环
break的作用是跳出当前循环块（for、while、do while）或程序块（switch）。在循环块中的作用是跳出当前正在循环的循环体。在程序块中的作用是中断和下一个case条件的比较。

continue

continue：结束本次循环，继续下一次的循环
continue用于结束循环体中其后语句的执行，并跳回循环程序块的开头执行下一次循环，而不是立刻循环体。

Systen.out.println(" " + 5 + 2)

52

---

第四章

访问权限修饰符

包语句的作用

使用包的主要原因是确保类名的唯一性

this关键字

意义

1、代表当前对象
2、this就是所在函数所属对象的引用，简单来说，哪个对象调用了this所在的函数，this就代表哪个对象

*类方法和实例方法的区别

类方法使用static修饰，而实例方法不用

//关于 static 关键字的使用，它可以用来修饰的成员变量和成员方法，
//被修饰的成员是属于类的，而不是单单是属于某个对象的。也就是说，既然属于类，就可以不靠创建对象来调用了。

//调用方式上
静态方法依赖于类，通过 类.静态方法 调用；
实例方法依赖于类的对象，需要创建对象后，对象.实例方法 使用

//使用上
'实例方法'内部不能定义静态变量，可以直接调用静态方法；
'静态方法'内部可以定义和使用实例变量，静态方法无法直接调用实例方法

//适用场景
静态方法：一个方法与类的对象无关，如工具类等
实例方法：一个方法依赖于类的对象；//多线程场景下，如果静态方法中含有静态变量，如果对静态变量进行更改操作易造成线程安全问题

//内存分配
一般认为静态方法常驻内存，实例方法只有在使用时才分配内存。但事实上，是一样的，都是在类被加载时常驻内存。

//实例方法出现的原因
创建c++、java、c#这样面向对象语言的大师引入实例化方法一定不是要解决什么性能、内存的问题，
而是
'为了让开发更加模式化、面向对象化'。这样说的话，
'静态方法和实例化方式的区分是为了解决模式的问题'

*方法重载的定义

方法定义在同一个类中，
某方法允许存在一个以上的同名方法，
只要他们的参数列表不同即可(参数类型、参数个数、参数顺序)。

*构造方法的定义

//构造方法的定义
构造方法是一种特殊的方法，它是一个与类同名的方法。对象的创建就是通过构造方法来完成，其功能主要是完成对象的初始化。

//构造方法的特征
它具有与类相同的名称；
它不含返回值；
它不能在方法中用 return 语句返回一个值；
当自定义了构造方法后，编译器将不再自动创建不带参数的构造方法 。
在构造方法里不含返回值的概念是不同于 “void” 的，在定义构造方法时加了 “void” ，结果这个方法就不再被自动调用了。

//构造方法的作用：
当一个类的实例对象刚产生时，这个类的构造方法就会被自动调用，
我们可以在这个方法中加入要完成初始化工作的代码。

---

第五章

final类的作用之类

类是单继承多接口的

抽象类

//抽象类的定义与使用

抽象类：在普通类的基础上扩充了一些抽象方法（0~n）的类（抽象类是普通类的超集），使用abstract关键字定义。

抽象类不能直接产生实例化对象，因为抽象类是“半成品”，无法直接使用。不能直接new

抽象方法：使用abstract 关键字定义并且没有方法体的方法。抽象方法所在类一定是抽象类。

//抽象类的使用原则
1）所有抽象类必须有子类 ：（abstract与final不能同时出现，编译出错）
2）如果子类不是抽象类 ，子类必须覆写抽象类（父类）的所有抽象方法。（子类是抽象类则可以不要求全部覆写）
3）抽象类可以使用子类向上转型对其实现实例化，抽象类一定不能直接实例化对象（无论是否有抽象方法）
4)由于抽象类强制要求子类覆写父类方法，所以private 与 abstract 不能同时使用。（private 修饰私有属性，被private修饰的属性和方法不能被外部使用）

多态

多态是在不同继承关系的类对象，去调用同一函数，产生了不同的行为

*子类继承父类的哪些功能

//从实例得出，子类可以继承父类中的public、protected域，不能继承父类中的private域，但可以通过父类的public访问器访问其私有域。
//如果父类没有提供public的访问器，子类就不能访问父类的私有域
 1、若父类中的成员（字段或方法）是以public修饰的，则子类无条件全继承；

 2、若父类中的成员（字段或方法）是以protected修饰的，则子类也全继承，即使子类与父类不在同一个包中；

 3、若父类和子类在同一个'包'中，此时子类可以继承父类中缺省修饰的成员。

 4、若父类中的成员（字段或方法）是以private修饰的，则子类无法继承父类的任何成员，因为private修饰的成员只能在本类中访问；

 5、父类中的构造器，子类也无法继承，因为构造器必须和当前的类名相同。

/*
* 定义员工类Employee，做为父类
* */
class Employee {
	String name; // 定义name属性
	// 定义员工的工作方法
	public void work() {
		System.out.println("尽心尽力地工作");
	}
}
/*
* 定义讲师类Teacher 继承 员工类Employee
*/
class Teacher extends Employee {
	// 定义一个打印name的方法
	public void printName() {
		System.out.println("name=" + name);
	}
}
/*
* 定义测试类
*/
public class ExtendDemo01 {
	public static void main(String[] args) {
		// 创建一个讲师类对象
		Teacher t = new Teacher();
		// 为该员工类的name属性进行赋值
		t.name = "小明";
		// 调用该员工的printName()方法
		t.printName(); // name = 小明
		// 调用Teacher类继承来的work()方法
		t.work(); // 尽心尽力地工作
	}
}

实例方法和静态方法（重复）

构造方法链

静态语句块优于对象存在，
执行顺序：父类静态语句块 -> 子类静态语句块 -> 父类构造方法 -> 子类构造方法。
静态语句块在类的初始化阶段被JVM调用。

假如有A、B两个类，A是B的父类，而且他们都有getX()这个方法，A、B的构造方法都调用getX()，当调用B的构造方法，先调用A的构造方法，而A的构造方法调用的是B中的getX()。

---

第六章

*6.8 接口和抽象类的区别

接口和抽象的区别

•飞机会飞，鸟会飞，他们都继承了同一个接口“飞”；
但是F22属于飞机抽象类，鸽子属于鸟抽象类。

•就像铁门木门都是门（抽象类），
你想要个门我给不了（不能实例化），
但我可以给你个具体的铁门或木门（多态）；
而且只能是门，你不能说它是窗（单继承）；
一个门可以有锁（接口）也可以有门铃（多实现）。 
门（抽象类）定义了你是什么，
接口（锁）规定了你能做什么（一个接口最好只能做一件事，你不能要求锁也能发出声音吧（接口污染）。

接口是多实现的，

---

第七章

异常类的祖宗类

Throwable类是所有错误跟异常类的超类（祖宗类）。

匿名内部类的方法

package com.zhf001;

public class Demo {

    public static void main(String[] args) {
        // 使用匿名内部类，必须是继承
          Person p=new Person(){
            @Override
            void eat() {
                // TODO Auto-generated metho
                System.out.println("eat somesthing");
            }

          };
          p.eat();
    }

}

try-catch重复

---

第八章

String的比较大小的方法equal()和Compareto()

方法equels（）比较两个字符串内容是否相等，返回值是boolean类型的值；
方法compareTo（）比较两个字符串大小，返回值是int的值。

StringBuffer和String的区别

StringBuilder概述

查阅java.lang.StringBuilder的API，StringBuilder又称为可变字符序列，它是一个类似于 String 的字符串缓冲区，通过某些方法调用可以改变该序列的长度和内容。

原来StringBuilder是个字符串的缓冲区，即它是一个容器，容器中可以装很多字符串。并且能够对其中的字符串进行各种操作。

它的内部拥有一个数组用来存放字符串内容，进行字符串拼接时，直接在数组中加入新内容。StringBuilder会自动维护数组的扩容。原理如下图所示：(默认16字符空间，超过自动扩充)

 String：适用于少量的字符串操作的情况
 StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况
 StringBuffer：适用多线程下在字符缓冲区进行大量操作的情况
 
 区别一：String类表示字符串，字符串常量一旦声明则不可改变，而字符串对象可以改变，但是改变的是其内存地址的指向。”所以String类不适合于频繁修改的字符串操作上，所以在这种情况下，往往可以使用StringBuffer类，即StringBuffer类方便用户进行内容修改，
 区别二：在String类中使用“+”作为数据的连接操作，而在StringBuffer类中使用append()方法（方法定义：public StringBuffer append(数据类型 变量)）进行数据连接。
 区别三：两个类的定义结构不同


 
//运行速度
StringBuilder > StringBuffer > String

Scanner的导包

import java.util.Scanner;

Date类、math类的使用

// 创建日期对象，把当前的时间
System.out.println(new Date()); // Tue Jan 16 14:37:35 CST 2018
// 创建日期对象，把当前的毫秒值转成日期对象
System.out.println(new Date(0L)); // Thu Jan 01 08:00:00 CST 1970
//把日期对象转换成对应的时间毫秒值。
public long getTime() 
//用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat。
public SimpleDateFormat(String pattern)
//将Date对象格式化为字符串。
public String format(Date date)
//将字符串解析为Date对象。
public Date parse(String source)



import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
 把Date对象转换成String
*/
public class Demo03DateFormatMethod {
    public static void main(String[] args) {
        Date date = new Date();
        // 创建日期格式化对象,在获取格式化对象时可以指定风格
        DateFormat df = new SimpleDateFormat("yyyy年MM月dd日");
        String str = df.format(date);
        System.out.println(str); // 2008年1月23日
    }
}

---

第十章

文本与IO从哪里扩展

JAVA多线程实现方式主要有三种：
继承Thread类、实现Runnable接口、使用ExecutorService、Callable、Future实现有返回结果的多线程。
其中前两种方式线程执行完后都没有返回值，只有最后一种是带返回值的。

对象流的原理

//ObjectInputStream与ObjectoutputStream

ObjectInputStream：将来源于硬盘或者其他网络的二进制的对象或基本数据类型的数据读入到内存（程序中），注意这的内存指的是电脑8GB的那个内存

ObjectInputStream也就是将二进制的数据读取为内存中的对象，也称为反序列化的过程

File类

---

第十一章

事件源

委托事件处理模式

多个监听器

事件驱动的编译

个人

连接数据库

访问数据库的Java程序主要有5个步骤，分别是：

1）加载驱动程序。

2）建立连接。

3）创建语句。

4）执行语句。

5）处理ResultSet。

Connection con;
String uri = "jdbc:mysql://localhost:3306/students?
				user=root&password= zhang&useSSL =true";
try{
	con = DriverManager.getConnection(uri);
}
catch(SQLException e){
	System.out.println(e);
}

/**
 * JDBC快速入门
 */
public class JdbcDemo1 {
    public static void main(String[] args) throws Exception {

        //1.导入驱动jar包
        //2.注册驱动
        //Class.forName("com.mysql.jdbc.Driver");
        //3.获取数据库连接对象
        Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db3", "root", "root");
        //Connection conn = DriverManager.getConnection("jdbc:mysql:/db3", "root", "root");
        //4.定义sql语句
        String sql = "update account set balance = 500 where id = 1 ";
        //String sql = "update account set balance = 2000";
        //5.获取执行sql的对象 Statement
        Statement stmt = conn.createStatement();
        //6.执行sql
        int count = stmt.executeUpdate(sql);
        //7.处理结果
        System.out.println(count);
        //8.释放资源
        stmt.close();
        conn.close();

    }
}

如何导入

---

第十二章

线程常用的方法 369

多线程有两种实现方法，分别是’继承Thread类’与’实现Runnable接口’
同步的实现方面有两种，分别是’synchronized’,‘wait’与’notify’

线程的创建

线程同步（线程互斥）

线程互斥:
当程序中存在临界资源时,为了使程序的执行具有可再现性,任一时间只能让一个线程对该资源进行操作即多个线程必须互斥地进入临界区

synchronized关键字互斥

互斥办法1:在含有临界区语句块的方法头中加上synchronized
互斥办法2:对临界区语句块附加synchronized

加锁互斥

互斥办法3:采用ReentrantLock类中lock()和unlock()方法对临界区语句块先加锁后解锁

---

第十三章

套接字

//套接字
在计算机网络中，我们常采用IP地址标识Internet.上
的计算机，用端口号标识正在计算机上运行的进程
(程序)。端口号被规定为-一个16位的0~65535之
间的整数。

IP地址与端口号的组合得出一个网络套接字。

在Java中，当两台主机.上的程序需要通信时，可以
通过使用Socket类和ServerSocket类建立客户端套
接字对象和服务器端套接字对象并连接在一起。

用户端和服务端连接的原理

UDP怎么接受，怎么发送，加入广播组

//UDP数据报
基于UDP的通信和基于TCP的通信不同，基于UDP
的信息传递更快，但不提供可靠性保证。

//基于UDP通信的基本模式是:
1.将数据打包，称为数据包(好比将信件装入信封一样)
2.然后将数据包发往目的地。
3.接受别人发来的数据包(好比接收信封一样)然后查看数据包中的内容。

---

第十四章

组件画图，重写pain方法

---

第十五章

泛型支持类和接口，不支持基本数据类型。

泛型：可以在类或方法中预支地使用未知的类型。

public class GenericDemo2 {
	public static void main(String[] args) {
        Collection<String> list = new ArrayList<String>();
        list.add("abc");
        list.add("itcast");
        // list.add(5);//当集合明确类型后，存放类型不一致就会编译报错
        // 集合已经明确具体存放的元素类型，那么在使用迭代器的时候，迭代器也同样会知道具体遍历元素类型
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            String str = it.next();
            //当使用Iterator<String>控制元素类型后，就不需要强转了。获取到的元素直接就是String类型
            System.out.println(str.length());
        }
	}
}

ArrayList

原因

到目前为止，我们想存储对象数据，选择的容器，只有对象数组。而数组的长度是固定的，无法适应数据变化的需
求。为了解决这个问题，Java提供了另一个容器 java.util.ArrayList 集合类,让我们可以更便捷的存储和操作对
象数据。

定义

java.util.ArrayList 是大小可变的数组的实现，存储在内的数据称为元素。此类提供一些方法来操作内部存储的元素。 ArrayList 中可不断添加元素，其大小也自动增长。

package programmingQuestions;
import java.util.ArrayList;

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

        ArrayList<String> arrayList = new ArrayList<>();

        arrayList.add("az");
        arrayList.add("as");
        arrayList.add("sd");

        for (int i = 0; i < arrayList.size(); i++) {
            System.out.println(arrayList.get(i));
        }
    }
}