java入门笔记+复习大纲+部分真题—（期末补救自己
我疯了别管我了
建议不要所有东西都等到ddl
序言-山财计算机科学与技术学院\(java\)考试题型
单项选择题（ $2 * 10 = 20 $分）
填空题($1 * 10 = 10 $分）
概念题（$5 * 4 = 20 $分）
阅读程序写运行结果 （$5 * 4 = 20 $分）
程序设计题（$ 15 $分）
图形界面及事件处理设计题（$ 15 $分）
一、\(java\)概述
1.掌握\(java\)源文件名称与类名之间的关系（主类、公共类）
-
一个\(java\)源文件中，如果有\(public\)类（包括抽象类，下同）或\(public\)接口，那么就只能有一个\(public\)类或一个\(public\)接口，不能有多个\(public\)的类或接口，当然可以有多个包可见的类或接口，即默认访问权限修饰符， 即类名前没有访问权限修饰符。
-
\(public\)类或接口与包可见的类或接口在文件中的顺序可以随意的顺序，即\(public\) 类或接口可以不在第一个的位置。
-
\(java\)源文件名必须与该\(public\)类名或\(public\)接口名相同。
如果将类MyClass声明为public，它的文件名称必须是（MyClass.java）才能正常编译。
-
一个\(java\)源文件中，如果既没有\(public\)类，又没有\(public\)接口，那么\(java\)源文件名没有限制。只要符合文件名的命名规范就可以，可以不与文件中任一个类或接口同名。当然也可以与其中之一同名。
-
同一包内，类和接口的命名不能冲突，即同一个包中的任何一个类名或接口名都是不同的。不同包，可以名字相同，因为通过包可以把它们区分开来。
2.了解\(java\)平台以及\(java\)语言的基本特点
\(Java\)语言是一种简单、面向对象、安全、平台独立、多线程、具有网络功能、执行效率较高的语言。（要考试了，有时间细嗦）
3.掌握\(java\)中注释的正确写法
\(Java\)中的注释方法有三种：
单行注释：以“//”开头，后面写注释
多行注释：以“/* ”开头，以“ */ ”结尾，格式：/ * +文字+ */
文档注释：以“/**”开头，以“*/”结尾，格式：/ ** +文字+ */
二、\(java\)语言基础
1.\(java\)标识符的正确写法
-
标识符是什么？程序员在定义\(java\)程序时，自定义的一些名字。标识符可以应用在类名、变量、函数名、包名上
-
标识符的书写规则有哪些
1.\(java\)中能用作标识符的有：26个英文字母(大、小写)，数字，下划线，美元符号$。 但是不能以数字开头
2.类名首个字母必须大写，多个单词组成的，每个单词首字母都要大写
3.方法名一般首个字母小写(构造方法例外)，多个单词组成方法名，后面单词首字母大写
4.变量命名规则同方法名名
注意：不能使用\(java\)中的关键字做标识符。
\(java\)保留关键字有哪些
\(Java\)语言有51个关键字，其中\(const\)和\(goto\)虽然被保留但未使用。我们不能使用保留关键字来命名类、方法或变量。
保留关键字
①数据类型：
Boolean int long short byte float double char class interface
②流程控制：
if else do while for switch case default break continue return try catch finally
③修饰符：
public protected private final void static strictfp abstract transient synchronized volatile native
④动作：
package import throw throws extends implements this Super instanceof new
⑤保留字：
true false null goto const
下面（A）不是Java的关键字。
A． integer B. double C. float D. char
2.掌握\(java\)中的变量类型（基本类型、引用类型）以及按照变量的位置分类（局部变量和成员变量）
- 基础类型变量：使用八种基础类型中的任一类型，声明出的变量。
八种基础类型：byte、short、int、long、float、double、boolean、char
- 引用类型变量：用三种引用类型中的任意一种类型，声明出的变量。引用类型变量，简称为引用，它可以用来接收对象，也叫做引用指向对象。
三种引用类型：类类型、接口类型、数组类型
- 局部变量、成员变量
| 局部变量 | 成员变量 | |
|---|---|---|
| 定义位置 | 方法中，或者方法的形式参数 | 在类中，方法外 |
| 初始化值 | 无，先定义，后赋值才能使用 | 有默认初始化值 |
| 调用方式 | 对象调用 | |
| 存储位置 | 栈 | 堆 |
| 生命周期 | 与方法一致 | 与对象一致 |
| 别名 | 实例变量 |
3.类型转换的规则
- 除\(boolean\)外，其余\(7\)类互相转换。
- 小容量---->大容量：自动转换
byte < short < int < long < float < double
char < int
- 大容量---->小容量：强制类型转换（可能损失精度）
下列代码的输出结果是：(D)(单选)
public static void main(String[] args){
double money = 3.0;
money-= 2.9;
System.out.println(money);
}
A、0.1 B、0.099 C、0 D、0.10000000000000009
下列数据类型转换，必须进行强制类型转换的是：(D)
A. byte → int B. short → long C. float → double D. int → char
- 当字面值没有超过\(byte，short，char\)范围，可以直接赋值。
//byte的数据范围是 -128~127
byte a=5;//编译通过
byte b= 128；//编译错误
//short的数据范围是 -32768～+32767
short x1=32767;//编译通过
short x2=32769;//编译错误
- \(byte，short，char\)混合运算，都先转换成int类型再运算。
char i='a'; byte j=1;
int k=i+j;//不会报错,正确的.
short s=i+j;//会报错,编译器不知道这个加法最后的结果是多少,只知道是 int 类型.
int a=1;
byte b=a;//会报错,编译器只知道 a 是 int 的类型,不知道所代表的具体数值,所以会报错.
- 多种数据混合运算，先转换成容量最大的类型再运算。
代码示例如下
public class Demo {
public static void main(String[] args) {
char t='a';
byte m=100;
short n=10;
float p=19f;
float sum=p+t-m+n;
//当各种数据类型混合运算时,会先转换成最大容量的数据类型,然后再去执行运算操作
//本质还是从左往右一个个变成最大容量的数据去进行运算的
//所以p+t-m+n就相当于是四个float类型的数据进行加减操作(从左往右执行)
System.out.println("混合运算的结果是: "+sum);
}
}
上述代码运行界面如下所示
又是一个小小例题
byte b1=1,b2=2,b3,b6,b8;final byte b4=4,b5=6,b7;
b3=(b1+b2); /*语句1*/
b6= b4+b5; /*语句2*/
b8=(b1+b4); /*语句3*/
b7=(b2+b5); /*语句4*/
System.out.println(b3+b6);
以上代码片段中,存在编辑错误的语句是(ACD)
A.语句1 B.语句2 C.语句3 D.语句4
解析：语句1错误：b3=(b1+b2);自动转为int，所以正确写法为b3=(byte)(b1+b2)，或者将b3定义为int
语句2正确：b4,b5都为final类型,不会自动提升，所以和的类型视左边变量类型而定
语句3错误：虽然b4不会自动提升，但是b1仍会自动提升，所以结果一样需要强转，b8=(byte)(b1+b4)
语句4错误：同上。同时要注意b7为final修饰，只能被赋值一次，然后就不能再改变了
4.熟练掌握\(java\)中的运算符的优先级；表达式的计算以及流程控制语句
运算基本规则
1)：通常从左到右
2): 一元高于二元高于三元
3): 优先 ()
4): 赋值最低
表达式的计算以及流程控制语句
偷的网址
Java表达式的计算（https://blog.csdn.net/x_i_y_u_e/article/details/46624661）
Java流程控制语句（https://blog.csdn.net/hjx980922/article/details/106158523）
5、熟练掌握\(java\)应用程序的结构（包括\(main\)的写法）
1.程序框架
public class HelloWorld()
\(HelloWorld\) 是类名，类名前面要用 $ public $ (公共的）和\(class\)(类）两个词修饰。\(Java\)程序是由类（\(class\)）组成的，一个源文件可以包含多个类。
2.main（）方法的框架
public static vaid main(String [] args){}
\(main\)方法是\(Java\)程序的入口，一个程序只能有一个\(main\)方法。
public static vaid main(String [] args){}为固定用法，称为\(main\)方法的“方法签名”。其中，\(public，static，void\)都是关键字。
3.填写代码
System.out.println("HelloWorld");
System.out.println( )是Java语言自带的功能，向控制台输出信息。
三、面向对象的程序设计
1.理解面向对象的基本概念(对象, 类等)以及面向对象的基本特征。
基本特征：封装、继承、多态
封装 可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用！
什么是封装？
封装可以隐藏实现细节，使得代码模块化；在面向对象编程上可理解为：把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。
封装的意义
封装的意义在于保护或者防止代码（数据）被我们无意中破坏。在面向对象程序设计中数据被看作是一个中心的元素并且和使用它的函数结合的很密切，从而保护它不被其它的函数意外的修改。
1.保护数据成员，不让类以外的程序直接访问或修改，只能通过提供的公共的接口访问 ==> 数据封装
2.方法的细节对用户是隐藏的，只要接口不变，内容的修改不会影响到外部的调用者 ==> 方法封装
3.当对象含有完整的属性和与之对应的方法时称为封装。
4.从对象外面不能直接访问对象的属性，只能通过和该属性对应的方法访问。
5.对象的方法可以接收对象外面的消息。
什么是继承？
继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。其继承的过程，就是从一般到特殊的过程。
通过继承创建的新类称为“子类”或“派生类”。被继承的类称为“基类”、“父类”或“超类”。要实现继承，可以通过“继承”（ \(Inheritance\) ）和“组合”（ \(Composition\) ）来实现。在某些 \(OOP\) 语言中，一个子类可以继承多个基类。但是一般情况下，一个子类只能有一个基类，要实现多重继承，可以通过多级继承来实现。
继承的方式
（1）继承概念的实现方式有三种：实现继承、接口继承和可视继承
（2）实现继承是指使用基类的属性和方法而无需额外编码的能力；
（3）接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力；
（4）可视继承是指子窗体（类）使用基窗体（类）的外观和实现代码的能力。
什么是多态？
“一个接口，多种方法”，同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。
多态的三个条件
a. 继承的存在(继承是多态的基础,没有继承就没有多态).
b. 子类重写父类的方法(多态下调用子类重写的方法).
c. 父类引用变量指向子类对象(子类到父类的类型转换).
重载（\(overload\)）和重写（$override4）是实现多态的两种主要方式。
实现多态
1.接口多态性
2.继承多态性
3.通过抽象类实现的多态性
2.掌握对象的声明，创建与使用。
对象的声明
类名 变量名 = new 类名()；
int apple = new int();
创建属于某个类的对象时，需要两个步骤：
（1）声明指向“由类所创建的对象”的变量；
（2）用 \(new\) 创建新对象，并且指派给先前所创建的变量
class Person { 定义一个Person类
private String name;
private int age;
public void talk();
}
Person p = new Person();
// 也可以用下面这个方法
Person p1; // 先声明Person类对象p1
p1 = new Person(); // 再用new关键字实例化Person的对象p1
对象只有在实例化之后才能够被使用，而实例化对象的关键字就是\(new\)
对象实例化过程如下
从图中可以看出，当语句执行到Person p1的时候，只是在“栈内存”中声明了一个Person对象p1的引用，但是这个时候p1并没有在“堆内存”中开辟空间。
对象的“引用”本质上就是一个对象在堆内存的地址，所不同的是，在Java中，用户无法向C/C++那样直接操作这个地址。
本质上，“new Person()”就是使用new关键字，来调用构造方法Person()，创建一个真实的对象，并把这个对象在“堆内存”中的占据的内存首地址赋予p1，这时p1才能称为一个实例化的对象。
对象的使用
如果要访问对象里的某个成员变量或方法，可以通过下面的语法来实现：
对象名称.属性名 //访问属性
对象名称.方法名() //访问方法
例如，想访问Person类中的name和age属性，可用如下方法来访问:
p1.name; //访问Person类中的name属性
p1.age; //访问Person类中的age属性
因此若想将Person类的对象p中的属性name赋值为“张三”，年龄赋值为25，则可采用下面的写法:
p1.name = "张三" ;
p1.age = 25 ;
如果想调用Person中的talk()方法，可以采用下面的写法:
p1.talk(); //调用Person类中的talk()方法
3.熟练掌握\(Java\)类以及测试类的编写。(成员变量, 构造方法，\(get/set\) 方法以及其他方法)。
4.构造方法的含义及写法。
//构造方法是类的一种特殊方法，用来初始化类的一个新的对象，在创建对象（new 运算符）之后自动调用。
Java 中的每个类都有一个默认的构造方法，并且可以有一个以上的构造方法
//如果类中没有编写构造方法，系统会默认该类只有一种构造方法，该默认的构造方法是无参数的，且方法体
内没有语句。
Lader(){
}
//默认构造方法与自定义构造方法
//如果类里定义了一个或多个构造方法，那么java不提供默认的构造方法
//静态方法只能访问静态成员，非静态成员可以访问静态成员，静态方法中不可使用this,super关键字。主
方法main()是静态的。
class Point{
int x,y;
Point(){
x=1;
y=1;
}
Point(int a,int b){
x=a;
y=b;
}
}
//构造方法没有类型
//构造方法没有类型下列Point类只有一个构造方法，其中的void,Point(int a,int b)和int Point()
都不是构造方法。
class Point{
int x,y;
Point(){//是构造方法
x=1;
y=1;
}
void Point(int a,int b){//不是构造方法(方法的类型是void)
x=a;
y=b;
}
int Point(){//不是构造方法(该方法的类型是int)
return 12;
}
}
5.掌握访问控制符(public, private, protected)的含义。
(1) private
用 private 修饰的类成员，只能被该类自身的方法访问和修改，而不能被任何其他类（包括该类的子类）访问和引用。因此，private 修饰符具有最高的保护级别。例如，设 PhoneCard 是电话卡类，电话卡都有密码，因此该类有一个密码域，可以把该类的密码域声明为私有成员。
(2). protected
用保护访问控制符 protected 修饰的类成员可以被三种类所访问：该类自身、与它在同一个包中的其他类以及在其他包中的该类的子类。使用 protected 修饰符的主要作用，是允许其他包中它的子类来访问父类的特定属性和方法，否则可以使用默认访问控制符。
(3)public
当一个类被声明为 public 时，它就具有了被其他包中的类访问的可能性，只要包中的其他类在程序中使用 import 语句引入 public 类，就可以访问和引用这个类。
类中被设定为 public 的方法是这个类对外的接口部分，避免了程序的其他部分直接去操作类内的数据，实际就是数据封装思想的体现。每个 Java 程序的主类都必须是 public 类，也是基于相同的原因。
