Java-期末复习资料整理

短命女 2023-01-02 08:22 205阅读 0赞

> 今天的题真的是妙蛙种子吃着妙脆角妙进了米奇妙妙屋 妙到家了

第一章

1.  面向过程和面向对象程序设计语言的区别  
    面向过程：给予解决问题的步骤的视角，将程序划分为单个功能，程序由函数+数据结构组成，两者独立分离  
    面向对象：以人观察世界的视角
2.  编译执行和解释执行语言的区别  
    编译执行的语言：将源代码转化成机器代码，然后直接交给操作系统执行，程序是作为一个整体来运行的  
    解释执行的语言：读一句执行一句不需要整体编译链接，与操作系统的相关性较小
3.  java的各个版本，javase javaee javame  
    JavaSE 桌面Java程序，基础包  
    JavaEE (Enterprise Evvironment) 企业级Java程序  
    JavaME (Mobile Environment) 移动设备和嵌入式设备Java开发
4.  什么是java虚拟机？工作原理是什么？jdk和jre的区别？  
    执行Java代码的虚拟机器  
    原理:把字节码解释成具体平台的机器指令执行  
    JDK(Java Development Kit)(Kit成套设备) Java开发工具包  
    JRE(Java Runtime Environment): 运行时环境

第二章

1.  标识符的命名规则
2.  变量使用三部曲：声明，赋值，使用
3.  如何定义常量？  
    final标识符
4.  基本数据类型（8种），占用的空间大小，给定一个常数，默认的类型，浮点数的两种表示方法  
    byte 1字节  
    int 4字节  
    long 8字节  
    float 4字节  
    double 8字节  
    Boolean 不确定(1字节或4字节,具体看JVM)
5.  基本数据类型的转换，向上和向下

层次高的类型转换成层次低的类型时,要加强制转换符,但可能造成降低精度  
第三章 类和对象  
（一）类和对象的基本概念

1.  面向对象语言的基本特点  
    封装性  
    继承性  
    多态性
2.  什么是类和对象，什么是封装性  
    类:同一类事物的共同特性的抽象定义
3.  java中所有对象都是引用类型。（内存分析）  
    Java中除了基本类型以外的变量类型都是引用类型
4.  对象的创建和使用（new）  
    Product p = new Product(new String(“bag”), 56.9, 90);
5.  JVM内存分配，堆、栈、数据、代码  
    堆: 存放new出来的对象  
    栈: 存放局部变量和引用变量  
    data segment: 存放静态变量和字符串常量  
    code segment: 存放代码

方法执行有其内存栈，所有本地变量(包括形参）按顺序压入栈中（后进先出）  
方法执行结束时其内存栈也将自然销毁  
6. java对象生命周期，什么是gc？工作原理？好处？  
7. 构造函数作用，定义要求。默认构造方法和对类成员的初始化。构造和初始化顺序（4步）。  
new初始化对象的顺序:  
(1) 申请内存空间，为新对象分配空间并初始化，所有基本类型数据设置成了默认值（如，整数类型是0，布尔型为false），而引用类型则被设置成null；  
(2) 执行显示初始化；(即指定默认值: private double discount = 1.0)  
(3) 执行构造方法；  
(4) 将对该对象的引用赋值给引用变量。  
8. 对象变量的传递，值传递和引用传递

1.  什么是方法重载？要求是什么？和方法重写有什么区别？
2.  this引用的作用
3.  静态数据成员和静态方法成员。静态成员和普通成员的互相访问

（二）包的概念  
12. 什么是包？如何定义包？命名规则是什么？如何使用包？哪些常用包？哪个包不显式导入就可使用？  
包: 类的组织形式  
命名规则：由大到小(域名的倒写)  
import 可以导入包  
lang 包自动导入  
注意：嵌套的包之间无任何关系  
13. 使用jar打包（考试不要求）

\[补充\]Java数组  
声明数组变量

1.  ElemType arr\[\];
2.  ElemType\[\] arr;  
    对于类的数组, 实际上是声明了一个引用变量的数组  
    （三）继承的概念\*\*\*\*\*  
    什么是继承？带来的好处是什么？  
    通过继承,子类自动拥有父类的所有普通成员  
    父类构造方法不能被子类继承  
    子类通过super(参数)调用父类构造方法  
    若子类构造方法中没有显式调用父类构造方法，则系统默认调用父类无参数的构造方法；若父类中没有定义无参数的构造方法，编译出错

注意：谨慎使用protected  
因为它相当于允许子类直接操作父类成员，破坏了父类的封装性，因此，应当优先使用父类的公有成员函数来操作子类中的父类对象

1.  如何实现继承？子类成员和父类成员有哪三种关系？  
    extends 父类  
    新增，重用，重写
2.  什么是重写？有哪些语法要求？  
    重写（Override）子类覆盖父类的同名方法  
    必须和被重写方法有相同的名称、参数列表  
    两小于等于：1）子类方法的返回值类型比父类方法的返回值类型更小（子类）或相等；子类方法声明抛出的异常类要比父类方法声明抛出的异常类更小（子类）或相等。  
    一大于等于：子类方法的访问权限要比父类方法的访问权限更大或相等。即，重写方法不能使用比被重写方法更严格的访问权限
3.  super关键字的作用什么？  
    指向父类
4.  子类的构造函数的执行过程。能否继承父类？如何显式调用父类构造函数？  
    public class FatherClass \{  
    private FatherClass() \{ //private 阻止了被继承,因为子类无法调用父类的构造函数  
    \}  
    public FatherClass getFather() \{  
    return new FatherClass();  
    \}  
    \}
5.  类成员的可访问性。（4个关键字）
6.  对象转型，向上，向下，instanceof关键字。  
    向下转型需要强制转化  
    向上转型不需要  
    引用 instanceof 类名：判断该引用所指向的对象是否属于该类或该类子类的对象  
    ==
7.  final方法和final类的含义  
    阻止方法(final方法)被重写（override）  
    final类：阻止类(final类)被继承  
    一个final类的所有方法都是final方法
8.  如何给java类加文档注释，如何生成文档（考试不要求）

（四）多态的概念\*\*\*\*\*\*\*  
22. 什么是多态，什么是动态绑定？多态实现的三点要求是什么？多态性是如何实现可扩展性和可维护性的？（如何在增加新类型时最小程度修改已有代码？）  
多态-同样的消息被不同类型的对象接收时产生 的不同的行为  
动态绑定-运行时判断所引用对象的实际类型,根据实际类型调用相应的方法  
多态存在的条件  
要有继承  
要有方法重写  
调用子类重写父类的方法  
动态多态性只针对非静态的成员方法  
23. 什么是抽象类？如何实现？抽象类是否能创建实例？  
抽象方法是一种没有实现的方法  
包含抽象方法的类：抽象类, 含有抽象方法的类必须定义为抽象类。  
abstract关键字  
抽象类不能创建（new）实例。  
子类未实现一个父类的抽象方法，该类仍为抽象类；只有当子类实现了全部抽象方法时才不再是抽象类  
24. 什么是接口？如何实现？接口是否能创建实例？接口中的成员数据有什么特殊之处？  
API（Application Programming Interface）  
一种类型，可看作一种特殊的抽象类。  
接口(抽象类)不能被实例化  
成员数据都是常量

1.  如何实现两个对象可比较大小？需要实现什么接口？  
    接口:Comparator
2.  抽象类和接口从设计目的到使用方法上有什么不同？(模板设计模式)
3.  面向对象设计的基本原则（开放封闭原则）
4.  Object类的作用，toString和equals方法，如何重写。
5.  如何定义数组？数组是什么类型？数组的内存图。数组的成员length。如何引用数组  
    声明数组变量:  
    ① int arr\[\];  
    ② int\[\] arr

数组的元素是引用类型

int \[\] s; //数组的定义  
s = new int \[2\]; //数组元素分配空间  
s\[0\] = 2; //给数组元素赋值  
System.out.printl(s.length);

Product[] ps = new Product[2];
    ps[0] = new Product();
    ps[1] = new Product(“shoe123”, 233, 20);

1.  如何为对象数组分配空间？  
    new 来为数组分配空间  
    products = new Products\[5\];
2.  如何初始化数组成员（静态初始化和动态初始化）？  
    静态初始化://知道就行了,尽量少用  
    int \[\] arr;  
    arr = new int \[\] \{ 2, 3, 4\};

动态初始化: 先分配空间,再赋值  
int \[\] arr;  
arr = new int \[2\];  
arr\[0\] = 1;  
arr\[1\] = 2;

1.  如何利用数组和多态性实现对某一大类事物的统一操作？  
    声明一个父类的数组  
    class A \{  
    final String str = “this is father A”;
    
    public A() \{
    
    \}
    
    public void print() \{  
    System.out.println(str);  
    \}  
    \}

class B extends A\{  
final String strB = “this is son B”;

public B() {
    	
    }
    
    @Override
    public void print() {
    	System.out.println(strB);
    }

class C extends A\{  
final String strC = “this is son C”;

public C() {
    	
    }
    
    @Override
    public void print() {
    	System.out.println(strC);
    }

public class Main\{  
public static void main(String\[\] args) throws ParseException \{  
Scanner sc = new Scanner(System.in);  
A \[\] As = new A\[5\];  
As\[0\] = new A();  
As\[1\] = new C();  
As\[2\] = new B();  
System.out.println(As.length);

As[0].print();
        System.out.println("-------------");
        As[1].print();
        System.out.println("-------------");
        As[2].print();
        System.out.println("-------------");
        sc.close();
    }

1.  main的参数是一个字符串数组（考试不要求）
2.  多维数组是数组的数组，可变长  
    二维数组:  
    int \[\]\[\] a = new int \[3\]\[\]; //有三行  
    a\[0\] = new int\[\]\{1\};  
    a\[1\] = new int \[10\];  
    a\[2\] = new int \[\]\{4, 5, 6\};
3.  数组拷贝（System.arraycopy）（考试不要求）
4.  工具类：Arrays，实现对数组操作方法，排序，复制，二分查找等。（考试不要求）  
    class BookComparatorByPrice implements Comparator \{
    
    @Override  
    public int compare(Book b0, Book b1) \{  
    if (b0.getPrice() > b1.getPrice())  
    return 1;  
    else if (b0.getPrice() < b1.getPrice())  
    return -1;  
    else \{  
    return b0.getName().compareTo(b1.getName());  
    \}  
    \}  
    \}  
    public class Main \{  
    public static void main(String\[\] args) \{  
    Scanner sc = new Scanner(System.in);  
    Book\[\] books = new Book\[4\];  
    //1. 从键盘接收用户输入的4本书的名称（仅有英文字符构成）、出版日期（格式：1998-10-09）、价格，生成Book对象，构造包含4本书的数组  
    for(int i=0;i<4;i++)\{  
    String name = sc.next();  
    String date\_str = sc.next();  
    Date date = null;  
    //将键盘录入的日期字符串转换为Date  
    SimpleDateFormat sdf = new SimpleDateFormat(“yyyy-MM-dd”);  
    try \{  
    date = sdf.parse(date\_str);  
    \} catch (ParseException e) \{  
    System.out.println(“日期格式有误”);;  
    \}
    
        double price = sc.nextDouble();
        	
        	Book book = new Book(name, date, price);
        	books[i] = book;
        }
        
        //按照价格升序
        Arrays.sort(books, new BookComparatorByPrice());
        for(Book book:books){
        	System.out.println(book);
        }
        sc.close();
    
    \}  
    \}

第四章 常用类  
String类和StringBuffer类\*\*\*\*\*\*

1.  String类和StringBuffer类的区别（可变长，不可变长）  
    String 不可变长  
    StringBuffer 可变长字符串, 线程安全
2.  String的连接（+）  
    String s = “Hello”;  
    s = s + ”World!”;
3.  String的常用方法（要求看见函数知道什么意思equals，charAt，length，indexOf，replace，startsWith，endWith，toLowerCase，toUpperCase，substring，trim，valueOf split）  
    boolean startsWith(String prefix)  
    测试此字符串是否以指定的前缀开始。  
    String  
    trim()  
    返回字符串的副本，忽略前导空白和尾部空白。  
    String  
    substring(int beginIndex)  
    返回一个新的字符串，它是此字符串的一个子字符串。  
    String  
    substring(int beginIndex, int endIndex)  
    返回一个新字符串，它是此字符串的一个子字符串。  
    String  
    toLowerCase()  
    使用默认语言环境的规则将此 String 中的所有字符都转换为小写。

用split将字符串以空格为分隔符  
str.split(“\\s+”);  
4. StringBuffer常用函数：append  
StringBuffer  
append(String str)  
将指定的字符串追加到此字符序列。  
StringBuffer  
delete(int start, int end)  
移除此序列的子字符串中的字符。  
StringBuffer  
insert(int offset, String str)  
将字符串插入此字符序列中。  
//offset 是指在第几个字符(位序)后面插入str  
Wrapper类  
5. Wrapper的作用  
Integer I1 = new Integer(10);  
Double D1 = new Double(“123.456”);  
Double D11 = new Double(123.456); //两种方法都可以  
Double D2 = 1.23;//自动封装  
int j1 = I1.intValue(); //手动解封(等同于类型转化)  
int j1 = I1.intValue(); //自动解封

常用函数：parseDouble，valueOf，intValue

static double parseDouble(String s)  
返回一个新的 double 值，该值被初始化为用指定 String 表示的值，这与 Double 类的 valueOf 方法一样。  
static Double  
valueOf(double d)  
返回表示指定的 double 值的 Double 实例。  
double doubleValue()  
返回此 Double 对象的 double 值。

Double D = Double.valueof(312.41);  
double d = D.doubleValue();  
int k = Integer.parseInt(“123”);

日期类  
6. 如何构造日期对象。参数是什么？why？  
Date date = null;  
//将键盘录入的日期字符串转换为Date  
SimpleDateFormat sdf = new SimpleDateFormat(“yyyy-MM-dd”);  
date = sdf.parse(date\_str);

before (when)

当且仅当此 Date 对象表示的瞬间比 when 表示的瞬间晚，才返回 true；  
long getTime()  
返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。  
void setTime(long time)  
设置此 Date 对象，以表示 1970 年 1 月 1 日 00:00:00 GMT 以后 time 毫秒的时间点。

1.  如何操作日历？如何获得日历对象实例？如何修改年月日时分秒等值？  
    protected Calendar()  
    构造一个带有默认时区和语言环境的 Calendar。  
    protected Calendar(TimeZone zone, Locale aLocale)  
    构造一个带有指定时区和语言环境的 Calendar。
2.  如何对日期进行格式化输出和解析？  
    format 格式化输出  
    parse 根据格式化字符串解析日期对象  
    applyPattern 应用某种格式  
    Date d = new Date();  
    SimpleDateFormat format = new SimpleDateFormat(  
    “yyyy-MM-dd HH-mm-ss”) ;  
    System.out.println(format.format(d));  
    format.applyPattern("EEE MM,dd,yyyy HH:mm:ss ");  
    System.out.println(format.format(d));  
    format.applyPattern(“MM,dd,yy HH:mm:ss”);  
    System.out.println(format.format(d));  
    Date d2 = format.parse(“10,31,16 19:18:56”);  
    System.out.println(d2);  
    SimpleDateFormat format2 = new SimpleDateFormat(  
    "EEE MM,dd,yyyy HH:mm:ss ", Locale.ENGLISH);  
    System.out.println(format2.format(d));

第五章 容器类

1.  容器类的继承结构，其中哪些是接口，表示什么含义？哪些是实现类？  
    Iterator: ListIterator  
    Collection:  
    Set: HashSet  
    List: ArrayList  
    LinkedList  
    Queue: LinkedList  
    Map:  
    HashMap  
    HashTable
2.  Collection接口的常用函数
3.  List接口的常用函数（index相关）  
    Object get(int index);  
    Object set(int index, Object element);  
    void add(Object element);  
    void add(int index,Object element);  
    Object remove(int index);  
    int indexOf(Object o);  
    int lastIndexOf(Object o);  
    List list = new LinkedList(); //限定容器中只能放String
4.  Queue接口的常用函数（offer peek poll）（考试不要求）
5.  Deque接口的特点和常用函数（双向队列）（考试不要求）
6.  LinkedList类的两个父类和常用接口（可以是队列，栈，链表）
7.  Set接口的常用实现类HashSet  
    Set s = new HashSet();
8.  hashcode原理
9.  Map接口的常用实现类HashMap，存储的数据类型（key-value，键不重复），常用方法：put、get、containsKey，containsValue，keySet
10. 迭代器的作用。如何获得迭代器？如何利用迭代器进行容器遍历？遍历过程中元素删除  
    Collection c = new HashSet();  
    c.add(new Product(“Book1",60,10));  
    c.add(new Product(“Book2",70,20));  
    Iterator i = c.iterator();  
    while(i.hasNext())\{  
    Product s = (Product)i.next();  
    System.out.println(s.getName());  
    \}

Set ks = map.keySet();  
Iterator i = ks.iterator();  
while (i.hasNext()) \{  
String key = (String)i.next();  
Integer value = (Integer)map.get(key);  
System.out.print (key+"-"+value+" ");  
\}

1.  For each循环，用for循环对所有容器类型遍历（不带下标的for循环）
2.  工具类： Collections，实现对容器操作方法，排序，复制，二分查找等。（考试不要求）

第六章 异常（不是重点）

1.  什么是异常？为什么要进行异常处理？
2.  异常的分类。Error，Runtime异常（未检查）和其他异常（检查）。检查异常和未检查异常的区别。
3.  java异常处理的基本过程？包含哪些关键字和代码块？
4.  一段代码抛出多个异常应当如何捕获？catch块的顺序如何安排？
5.  finally的作用？
6.  如何声明一个方法可能抛出的异常？
7.  如何构造异常对象并抛出？
8.  如何构造自定义的异常类？

第七章 流

1.  什么是流？流的三种基本分类方法。
2.  什么是字节流？什么是字符流？他们的继承结构中的最顶层类是什么？
3.  什么是节点流？什么是处理流？有哪些常见的节点流和处理流？
4.  InputStream类的作用？主要的方法：int read()，int read(byte\[\])，int read(byte\[\] buffer, int offset, int length)，close()。各个函数返回值的含义
5.  OutputStream类的作用？主要的方法。write(int)，write(byte\[\])，write(byte\[\] buffer, int offset, int length)，flush(), close()
6.  Reader类的作用？主要的方法int read()，int read(char\[\])，int read(char\[\] buffer, int offset, int length)，close()
7.  Writer类的作用？主要的方法write(int)，write(char\[\])，write(char\[\] buffer, int offset, int length)，flush(), close() write(String)，write(String buffer, int offset, int length)
8.  文件类File的含义（逻辑层面的文件和目录），常用方法
9.  文件操作流FileInputStream FileOutputStream FileReader FileWriter
10. 处理流的构造方式，如何嵌套，如何确定嵌套的顺序。
11. 缓冲流（4个），注意BufferedReader readline
12. 数据流（2个）的作用。常用函数
13. 对象流（2个）的作用，常用函数。序列化的含义和实现方法。Serializable ID序列号
14. 输入输出重定向的方法。System.setIn System.setOut