一、 java基础:(约5分)

1、Java 程序的结构

public class HelloWorld {/* 第一个Java程序* 它将输出字符串 Hello World*/public static void main(String[] args) {System.out.println("Hello World"); // 输出 Hello World}
}

2、编译结果

Hello World

3、编译命令

javac HelloWorld.java

4、执行命令

java Hello

5、Java 语言特点

简单、面向对象、平台无关、多线程、动态

二、java语言基础上(语法基础，50%题都会涉及):(>15分)

1、标识符定义规则

Java 所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。

关于 Java 标识符，有以下几点需要注意：

所有的标识符都应该以字母（A-Z 或者 a-z）,美元符（$）、或者下划线（_）开始
首字符之后可以是字母（A-Z 或者 a-z）,美元符（$）、下划线（_）或数字的任何字符组合
关键字不能用作标识符
标识符是大小写敏感的
合法标识符举例：age、$salary、_value、__1_value
非法标识符举例：123abc、-salary

2、简单数据类型

类型	说明	位数
boolean	布尔型	true 和 false
byte	字节型	8位 -128~127
char	字符型	16 位 Unicode 字符
double	双精度浮点	64 位
float	单精度浮点	32位
int	整型	32位
long	长整型	64 位
short	短整型	16位

3、表达式与代码段

表达式

int a = 16;

代码段

public class HelloWorld {/* 这是第一个Java程序* 它将输出 Hello World* 这是一个多行注释的示例*/public static void main(String[] args){// 这是单行注释的示例/* 这个也是单行注释的示例 */System.out.println("Hello World"); }
}

4、分支结构(两种)

if else 分支

if(布尔表达式){//如果布尔表达式的值为true
}else{//如果布尔表达式的值为false
}

switch case分支

switch(expression){case value ://语句break; //可选case value ://语句break; //可选//你可以有任意数量的case语句default : //可选//语句
}

5、循环结构(3 种)

while 循环

while( 布尔表达式 ) {//循环内容
}

do…while 循环

do {//代码语句
}while(布尔表达式);

for循环

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

三、面向对象知识:(核心内容，>40分)

1、面向对象的基本特性

面向对象具有继承、封装和多态 3 个核心特性。

继承性
如同生活中的子女继承父母拥有的所有财产，程序中的继承性是指子类拥有父类的全部特征和行为，这是类之间的一种关系。Java 只支持单继承。

封装性
封装是将代码及其处理的数据绑定在一起的一种编程机制，该机制保证了程序和数据都不受外部干扰且不被误用。封装的目的在于保护信息，使用它的主要优点如下。

保护类中的信息，它可以阻止在外部定义的代码随意访问内部代码和数据。
隐藏细节信息，一些不需要程序员修改和使用的信息，比如取款机中的键盘，用户只需要知道按哪个键实现什么操作就可以，至于它内部是如何运行的，用户不需要知道。
有助于建立各个系统之间的松耦合关系，提高系统的独立性。当一个系统的实现方式发生变化时，只要它的接口不变，就不会影响其他系统的使用。例如 U 盘，不管里面的存储方式怎么改变，只要 U 盘上的 USB 接口不变，就不会影响用户的正常操作。
提高软件的复用率，降低成本。每个系统都是一个相对独立的整体，可以在不同的环境中得到使用。例如，一个 U 盘可以在多台电脑上使用。

多态性
面向对象的多态性，即“一个接口，多个方法”。多态性体现在父类中定义的属性和方法被子类继承后，可以具有不同的属性或表现方式。多态性允许一个接口被多个同类使用，弥补了单继承的不足。

2、类与对象的关系

类是对象的抽象，对象是类的具体。
类是概念模型，定义对象的所有特性和所需的操作，对象是真实的模型，是一个具体的实体。
类是描述了一组有相同特性（属性）和相同行为（方法）的一组对象的集合。
对象或实体所拥有的特征在类中表示时称为类的属性
对象执行的操作称为类的方法。
类是构造面向对象程序的基本单位。

3、类的定义、构造方法、方法)

属性
在 Java 中类的成员变量定义了类的属性。例如，一个学生类中一般需要有姓名、性别和年龄等属性，这时就需要定义姓名、性别和年龄 3 个属性。声明成员变量的语法如下：

[ public | protected | private ] [static] [final] <variable_name>

各参数的含义如下。

public、protected、private：用于表示成员变量的访问权限。
static：表示该成员变量为类变量，也称为静态变量。
final：表示将该成员变量声明为常量，其值无法更改。
type：表示变量的类型。
variable_name：表示变量名称。

public class Student {public String name;    // 姓名final int sex = 0;    // 性别：0表示女孩，1表示男孩private int age;    // 年龄
}

构造方法

public class Puppy{public Puppy(){}public Puppy(String name){// 这个构造器仅有一个参数：name}
}

方法实列

public class Puppy{int puppyAge;public Puppy(String name){// 这个构造器仅有一个参数：nameSystem.out.println("小狗的名字是 : " + name ); }public void setAge( int age ){puppyAge = age;}public int getAge( ){System.out.println("小狗的年龄为 : " + puppyAge ); return puppyAge;}
}

4、构造方法的特点

每个类都有构造方法。如果没有显式地为类定义构造方法，Java 编译器将会为该类提供一个默认构造方法。
在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法。

5、对象的实例化过程

简单类对象的实例化过程

1、在方法区加载类；

2、在栈内存申请空间，声明变量P；

3、在堆内存中开辟空间，分配对象地址；

4、在对象空间中，对对象的属性进行默认初始化，类成员变量显示初始化；

5、构造方法进栈，进行初始化；

6、初始化完成后，将堆内存中的地址赋给引用变量，构造方法出栈；

6、this 的作用

1、this.属性名

大部分时候，普通方法访问其他方法、成员变量时无须使用 this 前缀，但如果方法里有个局部变量和成员变量同名，但程序又需要在该方法里访问这个被覆盖的成员变量，则必须使用 this 前缀。
在 Teacher 类的构造方法中使用了 this 关键字对属性 name、salary 和 age 赋值，this 表示当前对象。this.name=name语句表示一个赋值语句，等号左边的 this.name 是指当前对象具有的变量 name，等号右边的 name 表示参数传递过来的数值。
教师类：

public class Teacher {private String name;    // 教师名称private double salary;    // 工资private int age;    // 年龄
}// 创建构造方法，为上面的3个属性赋初始值
public Teacher(String name,double salary,int age) {this.name = name;    // 设置教师名称this.salary = salary;    // 设置教师工资this.age = age;    // 设置教师年龄
}
// 创建一个 main() 方法对 Teacher 类进行测试，代码如下：
public static void main(String[] args) {Teacher teacher = new Teacher("王刚",5000.0,45);System.out.println("教师信息如下：");System.out.println("教师名称："+teacher.name+"\n教师工资："+teacher.salary+"\n教师年龄："+teacher.age);
}

2、this.方法名
this 关键字最大的作用就是让类中一个方法，访问该类里的另一个方法或实例变量。
假设定义了一个 Dog 类，这个 Dog 对象的 run( ) 方法需要调用它的 jump( ) 方法，Dog 类的代码如下所示：

/*** 第一种定义Dog类方法**/
public class Dog {// 定义一个jump()方法public void jump() {System.out.println("正在执行jump方法");}// 定义一个run()方法，run()方法需要借助jump()方法public void run() {Dog d = new Dog();d.jump();System.out.println("正在执行 run 方法");}
}

this 可以代表任何对象，当 this 出现在某个方法体中时，它所代表的对象是不确定的，但它的类型是确定的，它所代表的只能是当前类的实例。只有当这个方法被调用时，它所代表的对象才被确定下来，谁在调用这个方法，this 就代表谁。
将前面的 Dog 类的 run( ) 方法改为如下形式会更加合适，run( ) 方法代码修改如下，其它代码不变。

/*** 第二种定义Dog类方法**/
// 定义一个run()方法，run()方法需要借助jump()方法
public void run() {// 使用this引用调用run()方法的对象this.jump();System.out.println("正在执行run方法");
}

3、this( )访问构造方法
下面定义一个 Student 类，使用 this( ) 调用构造方法给 name 赋值，Student 类的代码如下所示：

public class Student {String name;// 无参构造方法（没有参数的构造方法）public Student() {this("张三");}// 有参构造方法public Student(String name) {this.name = name;}// 输出name和agepublic void print() {System.out.println("姓名：" + name);}public static void main(String[] args) {Student stu = new Student();stu.print();}
}

7、super的作用

每当创建子类的实例时，父类的实例被隐式创建，由super关键字引用变量引用。
java super关键字的用法如下：

super可以用来引用直接父类的实例变量。

class Animal {String color = "white";
}class Dog extends Animal {String color = "black";void printColor() {System.out.println(color);// prints color of Dog classSystem.out.println(super.color);// prints color of Animal class}
}class TestSuper1 {public static void main(String args[]) {Dog d = new Dog();d.printColor();}
}

执行上面代码，输出结果如下

black
white

super可以用来调用直接父类方法。

class Animal {void eat() {System.out.println("eating...");}
}class Dog extends Animal {void eat() {System.out.println("eating bread...");}void bark() {System.out.println("barking...");}void work() {super.eat();bark();}
}class TestSuper2 {public static void main(String args[]) {Dog d = new Dog();d.work();}
}

执行上面代码，输出结果如下

eating...
barking...

super()可以用于调用直接父类构造函数。

class Animal {Animal() {System.out.println("animal is created");}
}class Dog extends Animal {Dog() {super();System.out.println("dog is created");}
}class TestSuper3 {public static void main(String args[]) {Dog d = new Dog();}
}

子类没有构造方法，自带隐式添加父类构造方法

class Animal {Animal() {System.out.println("animal is created");}
}class Dog extends Animal {Dog() {System.out.println("dog is created");}
}class TestSuper4 {public static void main(String args[]) {Dog d = new Dog();}
}

执行上面代码，输出结果如下

animal is created
dog is created

8、static 变量的内存分配与使用方法

java中的static关键字主要用于内存管理。我们可以应用java static关键字在变量，方法，块和嵌套类中。 static关键字属于类，而不是类的实例。
静态(static)可以是：
1.变量(也称为类变量)
2.方法(也称为类方法)
3.代码块
4.嵌套类
详细介绍

9、三个访问控制符的权限

Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
private : 在同一类内可见。使用对象：变量、方法。注意：不能修饰类（外部类）
public : 对所有类可见。使用对象：类、接口、变量、方法
protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。注意：不能修饰类（外部类）。

public class School {        // 外部类private static School instance = null;static class Teacher {}   // 内部类(静态)
}

10、继承的意义与使用方法

菜鸟教程-Java继承
1、继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。

2、继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

class 父类 {}class 子类 extends 父类 {}

11、多态性(重载、覆盖、父类引用子类对象)

菜鸟教程-多态性
多态的优点

消除类型之间的耦合关系
可替换性
可扩充性
接口性
灵活性
简化性

多态存在的三个必要条件

继承
重写
父类引用指向子类对象：Parent p = new Child();

class Shape {void draw() {}
}class Circle extends Shape {void draw() {System.out.println("Circle.draw()");}
}class Square extends Shape {void draw() {System.out.println("Square.draw()");}
}class Triangle extends Shape {void draw() {System.out.println("Triangle.draw()");

虚函数
虚函数的存在是为了多态。

Java 中其实没有虚函数的概念，它的普通函数就相当于 C++ 的虚函数，动态绑定是Java的默认行为。如果 Java 中不希望某个函数具有虚函数特性，可以加上 final 关键字变成非虚函数。

重写
我们将介绍在 Java 中，当设计类时，被重写的方法的行为怎样影响多态性。

我们已经讨论了方法的重写，也就是子类能够重写父类的方法。

当子类对象调用重写的方法时，调用的是子类的方法，而不是父类中被重写的方法。

要想调用父类中被重写的方法，则必须使用关键字 super。

多态的实现方式

方式一：重写：
这个内容已经在上一章节详细讲过，就不再阐述，详细可访问：Java 重写(Override)与重载(Overload)。

方式二：接口

生活中的接口最具代表性的就是插座，例如一个三接头的插头都能接在三孔插座中，因为这个是每个国家都有各自规定的接口规则，有可能到国外就不行，那是因为国外自己定义的接口类型。
java中的接口类似于生活中的接口，就是一些方法特征的集合，但没有方法的实现。具体可以看 java接口这一章节的内容。

方式三：抽象类和抽象方法

12、final 的作用

Java final修饰符详解
final 在 Java 中的意思是最终，也可以称为完结器，表示对象是最终形态的，不可改变的意思。final 应用于类、方法和变量时意义是不同的，但本质是一样的，都表示不可改变，类似 C# 里的 sealed 关键字。

使用 final 关键字声明类、变量和方法需要注意以下几点：

final 用在变量的前面表示变量的值不可以改变，此时该变量可以被称为常量。
final 用在方法的前面表示方法不可以被重写（子类中如果创建了一个与父类中相同名称、相同返回值类型、相同参数列表的方法，只是方法体中的实现不同，以实现不同于父类的功能，这种方式被称为方法重写，又称为方法覆盖。这里了解即可，教程后面我们会详细讲解）。
final 用在类的前面表示该类不能有子类，即该类不可以被继承。

13、抽象类的概念，接口的作用

菜鸟教程-Java 抽象类

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。
由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。
父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。
在 Java 中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。

抽象方法
如果你想设计这样一个类，该类包含一个特别的成员方法，该方法的具体实现由它的子类确定，那么你可以在父类中声明该方法为抽象方法。

Abstract 关键字同样可以用来声明抽象方法，抽象方法只包含一个方法名，而没有方法体。

抽象方法没有定义，方法名后面直接跟一个分号，而不是花括号。

public abstract class Employee
{private String name;private String address;private int number;public abstract double computePay();//其余代码
}

声明抽象方法会造成以下两个结果：

如果一个类包含抽象方法，那么该类必须是抽象类。
任何子类必须重写父类的抽象方法，或者声明自身为抽象类。

继承抽象方法的子类必须重写该方法。否则，该子类也必须声明为抽象类。最终，必须有子类实现该抽象方法，否则，从最初的父类到最终的子类都不能用来实例化对象。
如果Salary类继承了Employee类，那么它必须实现computePay()方法：

/* 文件名 : Salary.java */
public class Salary extends Employee
{private double salary; // Annual salarypublic double computePay(){System.out.println("Computing salary pay for " + getName());return salary/52;}//其余代码
}

抽象类总结规定

抽象类不能被实例化(初学者很容易犯的错)，如果被实例化，就会报错，编译无法通过。只有抽象类的非抽象子类可以创建对象。
抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能。
构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法。
抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。

14、包的作用和使用

包的 3 个作用如下：

区分相同名称的类。
能够较好地管理大量的类。
控制访问范围。

包定义
Java 中使用 package 语句定义包，package 语句应该放在源文件的第一行，在每个源文件中只能有一个包定义语句，并且 package 语句适用于所有类型（类、接口、枚举和注释）的文件。定义包语法格式如下：

package 包名;

Java 包的命名规则如下：

包名全部由小写字母（多个单词也全部小写）。
如果包名包含多个层次，每个层次用“.”分割。
包名一般由倒置的域名开头，比如 com.baidu，不要有 www。
自定义包不能 java 开头。

四、Java常用类(>20分):

1、数组的初始化与引用

double[] myList;         // 首选的方法double myList[];         //  效果相同，但不是首选方法arrayRefVar = new dataType[arraySize]; //创建数组

2、字符串对象的定义

String 创建的字符串存储在公共池中，而 new 创建的字符串对象在堆上：

String s1 = "Runoob";              // String 直接创建
String s2 = "Runoob";              // String 直接创建
String s3 = s1;                    // 相同引用
String s4 = new String("Runoob");   // String 对象创建
String s5 = new String("Runoob");   // String 对象创建

3、多种字符串处理方法

String 类的一个访问器方法是 length() 方法，它返回字符串对象包含的字符数。

public class StringDemo {public static void main(String args[]) {String site = "www.runoob.com";int len = site.length();System.out.println( "菜鸟教程网址长度 : " + len );}
}

连接字符串

String 类提供了连接两个字符串的方法：

string1.concat(string2);

返回 string2 连接 string1 的新字符串。也可以对字符串常量使用 concat() 方法，如：

"我的名字是 ".concat("Runoob");

更常用的是使用’+'操作符来连接字符串，如：

"Hello," + " runoob" + "!"

4、常用的列表及使用方法。

Java 语言中提供的数组是用来存储固定大小的同类型元素。

Arrays 类
java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。

具有以下功能：

给数组赋值：通过 fill 方法。
对数组排序：通过 sort 方法,按升序。
比较数组：通过 equals 方法比较数组中元素值是否相等。
查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。

五、Java图形用户界面:(约17分)

1、自定义窗口类

2、常用控件(文本输入框、选择类、按钮、标签等)的创建、处理、显示/获取数据方法，

3、三种常见的布局管理器，

事件的添加过程(三步，三种方式，ActionEvent、 KeyEvent、WindowEvent 事件的监听器及处理方法必须掌握)。

六、 Java异常处理:(约3分)

1、异常捕捉与处理模式(try…catch…finally)

异常是程序中的一些错误，但并不是所有的错误都是异常，并且错误有时候是可以避免的。

比如说，你的代码少了一个分号，那么运行出来结果是提示是错误 java.lang.Error；如果你用System.out.println(11/0)，那么你是因为你用0做了除数，会抛出 java.lang.ArithmeticException 的异常。

异常发生的原因有很多，通常包含以下几大类：

用户输入了非法数据。
要打开的文件不存在。
网络通信时连接中断，或者JVM内存溢出。

这些异常有的是因为用户错误引起，有的是程序错误引起的，还有其它一些是因为物理错误引起的。-
要理解Java异常处理是如何工作的，你需要掌握以下三种类型的异常：

检查性异常：最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。
运行时异常：运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。
错误：错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。

捕获异常
使用 try 和 catch 关键字可以捕获异常。
try/catch 代码块放在异常可能发生的地方。
try/catch代码块中的代码称为保护代码，使用 try/catch 的语法如下：

try
{// 程序代码
}catch(ExceptionName e1)
{//Catch 块
}catch(ExceptionName e1)
{//Catch 块
}

Catch 语句包含要捕获异常类型的声明。当保护代码块中发生一个异常时，try 后面的 catch 块就会被检查。

如果发生的异常包含在 catch 块中，异常会被传递到该 catch 块，这和传递一个参数到方法是一样。

finally关键字

finally 关键字用来创建在 try 代码块后面执行的代码块。
无论是否发生异常，finally 代码块中的代码总会被执行。
在 finally 代码块中，可以运行清理类型等收尾善后性质的语句。

finally 代码块出现在 catch 代码块最后，语法如下：

try{// 程序代码
}catch(异常类型1 异常的变量名1){// 程序代码
}catch(异常类型2 异常的变量名2){// 程序代码
}finally{// 程序代码
}

2、抛出异常(throw，throws)

throws 声明异常
当一个方法产生一个它不处理的异常时，那么就需要在该方法的头部声明这个异常，以便将该异常传递到方法的外部进行处理。使用 throws 声明的方法表示此方法不处理异常。throws 具体格式如下：

returnType method_name(paramList) throws Exception 1,Exception2,…{…}

import java.io.*;
public class className
{public void deposit(double amount) throws RemoteException{// Method implementationthrow new RemoteException();}//Remainder of class definition
}

3、常见的异常。

异常	描述
ArithmeticException	当出现异常的运算条件时，抛出此异常。例如，一个整数"除以零"时，抛出此类的一个实例。
ArrayIndexOutOfBoundsException	用非法索引访问数组时抛出的异常。如果索引为负或大于等于数组大小，则该索引为非法索引。
ArrayStoreException	试图将错误类型的对象存储到一个对象数组时抛出的异常。
ClassCastException	当试图将对象强制转换为不是实例的子类时，抛出该异常。
IllegalArgumentException	抛出的异常表明向方法传递了一个不合法或不正确的参数。

七、文件和流:(约5分)

1、File 类

2、常用输入输出流的类和方法。

//文件名 :fileStreamTest2.java
import java.io.*;public class fileStreamTest2 {public static void main(String[] args) throws IOException {File f = new File("a.txt");FileOutputStream fop = new FileOutputStream(f);// 构建FileOutputStream对象,文件不存在会自动新建OutputStreamWriter writer = new OutputStreamWriter(fop, "UTF-8");// 构建OutputStreamWriter对象,参数可以指定编码,默认为操作系统默认编码,windows上是gbkwriter.append("中文输入");// 写入到缓冲区writer.append("\r\n");// 换行writer.append("English");// 刷新缓存冲,写入到文件,如果下面已经没有写入的内容了,直接close也会写入writer.close();// 关闭写入流,同时会把缓冲区内容写入文件,所以上面的注释掉fop.close();// 关闭输出流,释放系统资源FileInputStream fip = new FileInputStream(f);// 构建FileInputStream对象InputStreamReader reader = new InputStreamReader(fip, "UTF-8");// 构建InputStreamReader对象,编码与写入相同StringBuffer sb = new StringBuffer();while (reader.ready()) {sb.append((char) reader.read());// 转成char加到StringBuffer对象中}System.out.println(sb.toString());reader.close();// 关闭读取流fip.close();// 关闭输入流,释放系统资源}
}

试题类型(分数大致分布如下):

一、选择题(561)
二、填空题(112)
三、编程题1(程序填空):类与对象(110)
四、编程题2(程序填空):窗口应用(112)

Java期末复习——知识点+题库相关推荐

数据结构与算法期末复习——知识点+题库
第一章绪论 1.1 数据结构的基本概念 (1)数据:所有能被计算机识别.存储和处理的符号的集合(包括数字.字符.声音.图像等信息 ). (2)数据元素:是数据的基本单位,具有完整确定的实际意义.在计算 ...
java期末判断题题库_(java期末考试选择题题库.doc
(java期末考试选择题题库 1.分析以下程序: 1)public class x{ 2)public static void main(String[]args){ 3)String ol=new ...
Java期末复习知识点总结
一.Java程序概述 1.特性简单性.高性能.编译性.解释性.分布式处理.健壮性.安全性.面向对象.开源.跨平台 2. 3.JDK.JRE.JVM JDK:Java开发工具包包含:JAVA开发工具 ...
Java期末复习知识点下
碎碎念~ 终于来到了最后一堆啦,但其实好像前面的知识也没有消化地很好,但是会在不断地码代码的过程中好好吸收消化这些知识滴~ 完结撒花~ 在末尾的那一些知识其实自己还是没有理解好,最主要的是怎么把知识转 ...
java switch case怎么判断范围_【转】Java期末复习攻略！
期末 19年就这样要过去了, 终于到了小时候作文里的未来呢! 然而,期末考试也随之来临了. 不知大家"预习"的怎么样呢? 期末复习资料的放送快接近尾声了下面康康学长学姐们怎么教 ...
Java数据结构第五版期末考试_数据结构(java)期末复习
[单选题]多基因遗传病的发病风险与下列哪个因素无关 [单选题]一般手锯的往复长度不应小于锯条长度的( ). [判断题]机器上所有;零件都必须进行机械加工. [单选题]一般划线精度能达到( ). [填空 ...
python期末复习知识点总结
期末复习知识点总结第一章 1.6 Python编程规范与代码优化建议 1.7 模块模块的导入方式补:Python编程规范与代码优化建议注释以符号#开始,表示本行#之后的内容为注释. #eg1 ...
数据库期末复习知识点:（仅供参考）
数据库期末复习知识点: 一运用SQL 基本sql语句授权sql语句: 实体完整性sql语句: 二 ER 画出ER图,并转换成关系模式. 三.范式范式存储结构一运用SQL 基本sql语句 (1) ...
山东大学软件工程期末复习知识点总结
山大软院软件工程期末复习知识点总结,根据任课老师所给提纲及课件等资料进行整理. 考试范围全覆盖. 文档电子版下载地址目录第一章 1.1软件工程(SE)的定义.目的.方法.作用: //1.2开发模式 ...
计算机导论期末考试知识点,计算机导论期末复习(知识点).doc
计算机导论期末复习(知识点) 计算机导论期末复习(知识点) 单选题30%(每题1分,总30分) 判断题20%(每题1分,总20分) 问答题30%(7题左右,总30分) 综合回答题20%(2题,总20分 ...

Java期末复习——知识点+题库

一、 java基础:(约5分)

1、Java 程序的结构

2、编译结果

3、编译命令

4、执行命令

5、Java 语言特点

二、java语言基础上(语法基础，50%题都会涉及):(>15分)

1、标识符定义规则

2、简单数据类型

3、表达式与代码段

4、分支结构(两种)

5、循环结构(3 种)

三、面向对象知识:(核心内容，>40分)

1、面向对象的基本特性

2、类与对象的关系

3、类 的定义、构造方法、方法)

4、构造方法的特点

5、对象的实例化过程

6、this 的作用

7、super的作用

8、static 变量的内存分配与使用方法

9、三个访问控制符的权限

10、继承的意义与使用方法

11、多态性(重载、 覆盖、父类引用子类对象)

12、final 的作用

13、抽象类的 概念，接口的作用

14、包的作用和使用

四、Java常用类(>20分):

1、数组的初始化与引用

2、字符串对象的定义

3、多种字符串处理方法

4、常用的列表及使用方法。

五、Java图形用户界面:(约17分)

1、自定义窗口类

2、常用控件(文本输入框、选择类、按钮、标签等)的创建、处理、显示/获取数据方法，

3、三种常 见的布局管理器，

六、 Java异常处理:(约3分)

1、异常捕捉与处理模式(try…catch…finally)

2、抛出异常(throw，throws)

3、常见的异常。

七、 文件和流:(约5分)

1、File 类

2、常用输入输出流的类和方法。

试题类型(分数大致分布如下):

Java期末复习——知识点+题库相关推荐

最新文章

热门文章

3、类的定义、构造方法、方法)

11、多态性(重载、覆盖、父类引用子类对象)

13、抽象类的概念，接口的作用

3、三种常见的布局管理器，

七、文件和流:(约5分)