JAVA知识点总结

• 类 • 方法 • 继承

• 多态 • 重载 • 抽象类 • 接口 • 包• 作用域

• java核心类 • 常用工具类 • 枚举

类

• 类是定义相同类型对象的结构。
• Java类使用变量来定义数据域，而用方法来
定义行为。
• 此外,类还提供了一种特殊类型的***方法***，这种方法被称为构造方法，当你用类来构建对象时会调用构造方法。
方法即函数

class 和instance

• class

– 对象模板
– 定义了如何创建实例
– 名字就是数据类型

• instance

– 对象实例
– 是根据class创建的实例
– 可以创建多个instance
– 各个instance类型相同，但
属性可以不尽不同

每个类都提供两个合约：
– 一个是针对该类的使用用户，
– 一个是针对该类的扩展用户。
• 对使用用户而言使数据域私有化和访问器方法
公共化，对扩展用户而言数据域和方法是
protected的。
• 扩展类可以提高一个实例方法的可见性，使方
法从protected变为public，或者改变它的实现，
但是不能以违背类协议的方式改变实现。

private修饰符

• 一个类应该使用***private修饰符***来隐藏它的数
据，防止客户端直接访问。
– 但只有希望用户看到或修改私有数据，你可以使用get方法和set方法为用户提供对私有数据的访问。
– 一个类还应该隐藏当它不打算供客户端使用的方法。

静态方法: 只能调用static;

实例方法都行
创建实例

形式参数

定义在方法头的变量被称作形式参数。
实际参数
当方法被调用时，就传递给参数一个值。这个
值被称作实际参数或实参。

返回数据类型

• 方法可以返回一个值。returnValueType是方法返回值的数据
类型。
• 如果方法不返回值，那么returnValueType就是关键字 void。 ➢ 例如：在 main 方法中returnValueType 就是void。

实例引用：this

this 就是防止重名
方法内部可以使用隐式变量this
• this指向当前实例
• this.field可以访问当前实例的字段

private方法

一类特殊的方法：构造方法

默认的构造方法

• 如果没有显式地定义类的构造方法，编译器会自动
为该类定义一个默认的构造方法。
– 该构造方法不含任何参数
– 无执行语句
– 默认的构造方法首先调用其父类的不含任何参数的构造
方法，然后初始化新生成的实例的各个成员域变量

构造方法

• 一旦在类中定义了构造方法，系统就不会再创建这
个默认的不含参数的构造方法；
•

默认值

: 基本数值类型: 0; boolean: false; 引用数据
类型: null

方法重载（Overload）

public class hello{
public void hello(String name){
}
public void hello(int age){
}
public void hello(String name,int age){
}
public void hello(int age, String name){
}

区别重载和覆写

几个常用类

包括包：

java.util.Random
Random 类举例
如果两个Random 对象有相同的种子，那它们将生成两
个相同的数字序列。例如：下面的代码用相同的种子3
生成了两个 Random 对象。

Random random1 = new Random(3);
System.out.print("From random1: ");
for (int i = 0; i < 10; i++)
System.out.print(random1.nextInt(1000) + " ");
Random random2 = new Random(3);
System.out.print("\nFrom random2: ");
for (int i = 0; i < 10; i++)
System.out.print(random2.nextInt(1000) + " ");

## Math类

 • 类常量
– PI
– E 
• 类方法
– 三角函数方法
– 指数函数方法
– 取整方法
– min、max、abs和random方法


## 取整方法
Math.ceil( x  )   超过x的最小整数
Math.floor( x  )  不超过x 的 最大整数
 double rint(double x)   x取离它最接近的整数。如果 x 距离两个整数同样接近，就返回成偶数的double类型值。


取整方法举例
Math.ceil(2.1) 返回 3.0 
Math.ceil(2.0) 返回 2.0
Math.ceil(-2.0) 返回 –2.0
Math.ceil(-2.1) 返回 -2.0
Math.floor(2.1) 返回 2.0
Math.floor(2.0) 返回 2.0
Math.floor(-2.0) 返回 –2.0
Math.floor(-2.1) 返回 -3.0
Math.rint(2.1) 返回 2.0
Math.rint(2.0) 返回 2.0
Math.rint(-2.0) 返回 –2.0
Math.rint(-2.1) 返回 -2.0
Math.rint(2.5) 返回 2.0
Math.rint(-2.5) 返回 -2.0
Math.round(2.6f) 返回 3 
Math.round(2.0) 返回 2 
Math.round(-2.0f) 返回 -2 
Math.round(-2.6) 返回 -3

## min、max和 abs
* 
* max(a, b)和min(a, b）
返回两个参数的最大和最 小值。
• abs(a)
返回参数的绝对值。 
• random()
返回大于等于0.0且小于1.0的 double 型随机数。



一、继承



在Java中实现继承
• 在Java中实现继承需要使用到extends关键字；
• 实现继承的一般语法是：

```java
[访问修饰符] class 派生类名 extends 基类名 {
成员列表
} • 如：
class Student extends Person
{
……
}

继承树

*

Object类

*

protected

public class Person{
private String name;
private int age;
public void setName(String name){…}
}
public class Student extends Person{
public String hello(){
return “Hello, ” + this.name //编译错误
} }

• Person 类定义的private字段无法被子类访问
• 用protected修饰的字段可以被子类访问
• protected把字段和方法的访问权限控制在继承树内部

super

关键字super

是指这个super出现的类的父类。这
个关键字super有以下两种途径：
• 调用父类的构造方法
• 调用父类的方法

public class Person {
protected String name;
private int age;
public Person(String name) {
this.name = name;
}
……
}
public class Student extends Person{
public Student(String name) {
super(name);
……
} }

super关键字表示父类（
超类）
• 构造方法的第一行语句
必须调用super（）
• 没有super（）时编译器会自动生成super（）
• 如果父类没有默认构造方法，子类就必须显式调用super（）

super（补充）

public class Person {
private String name;
private int age;
public String hello() {
return "Hello, " + this.name;
}}
public class Student extends Person{
public String hello() {
return super.hello() + "!"; 
} 
}
public class Main {
public static void main(String[] args) {
Person p = new Student("Alice");
System.out.println(p.hello());
} }

this是找自己的属性
super是找父类的属性

super可以调用（可能是跨两层的）父类的被覆写（Override）的方法

final

final方法举例

不能被
override；

final变量举例

用final修饰的字段在初始
化后不能被修改。

final 类举例

用final修饰的类不能被继
承；

public class Person {
public final void setName(String 
name) {
……
} 
}
public final class Student extends 
Person{ 
private final int score; 
…… 
}

向上转型（upcasting）

• 实例变量可以进行向上转型；
• 向上转型是将一个子类型安全地变为更
加抽象的类型。
Person p = new Person();
Student s = new Student();
Person ps = new Student(); //向上转型
Object o1 = p ; //向上转型
Object o2 = s ; //向上转型

向下转型（抽象变具体是不对的）（downcasting）

• 实例变量可以进行向下转型；
• 向下转型是将一个抽象类型变成一个具体的子类型；
• 向下转型有可能会报错：ClassCastException
Person p = new Person();
Student s = （Student）p; //向下转型，编译错误

instanceof 操作符

就是向下转型的时候，需要前面加（man）P 这样，
这里需要判读，P 是不是man类型的，
所以引入 instanceof ()
判断会不会转错了

Person p2= new man();
然后对p2进行强制转换。

• instanceof 操作符用于判断对象的类型。
Person p = new Person();
if(p instanceof Person)
if(p instanceof Student)
Student s = new Student();
if(s instanceof Person)
if(s instanceof Student)
//true
//false
//true
//true

父类强制转换成Man类型

向下转型可以用instanceof判断，以避免运行时错误。
Person p = new Student();
if(p instanceof Student) {
Student s = (Student) p;
… }

继承和组合

public class Person{
private String name;
private int age;
public void setName(String name){…}
}
public class Book{
private String name;
}
public class Student extends Person{
private Book book;
private int score;
……
}

覆写（Override）

public class Person{
public void run(){……}
}
public class Student extends 
Person{
@Override
public void run(){……} 
}

========================================================
子类覆写父类的方法是覆写
（Override），指子类定义了
与父类***相同返回值和参数的
方法***；

• 方法签名如果不同就不是
Override，而是创建了一个新
的方法；
• 加上@Override可以让编译器
帮助检查是否进行了正确的
覆写；
• @Override不是必须的。

多态

**

引用变量的类型可能与实际类型不符；
• 实例对象的方法调用总是对应实际类型；
• Java的实例方法调用是***基于运行时实际类型的动态调用***，这种动态调用称为多态。

多态（Polymorphic）

• 多态是指针对某个类型的方法调用，其真正执行的方法取决于运行时期实际类型的方法；
• 对某个类型调用某个方法，执行的方法可能是某个子类的***覆写***方法；
• 利用多态，允许添加更多类型的子类实现功能扩展。

虚拟方法调用（动态绑定）

Java的访问控制符

Java的访问控制符种类：
public 公共的，修饰类、属性和方法
private 私有的，修饰属性和方法
protected 受保护的，修饰属性和方法

公共访问控制符 public

• public——“公有的、公共的”，它不仅可以修饰类，
还可以修饰属性（成员变量）和方法。 • 当程序中有多个类时，最多只能有一个类被public修 饰，程序名必须命名为public修饰的类名。 • 当用public修饰成员变量和方法时，变量和方法可以
被任何程序直接访问和修改。但这不利于保证数据的
一致性，造成安全性和可靠性的下降。

缺省的修饰符

• 如果一个类、属性和方法前面没有被访问控制符修
饰，说明它具有缺省的访问控制特性（也叫包访问
特性），访问范围 ： – 属性和方法所在的类。
– 同一个包内的其它类。

私有访问控制符 private

• private——私有的，修饰属性和方法。 • 被private修饰的属性和方法是私有的，只能被
定义它们的类访问和调用。其它任何类都不能
访问私有属性和私有方法。

抽象类:从覆写说起

public class Person {
public void run(); { …… }
}
public class Student extends Person{
@Override
public void run() { …… }; 
…… 
}
public class Teacher extends Person{
@Override
public void run() { …… }; 
…… 
}

• 每个子类都可以覆写父类的方法。
• 如果父类的方法没有实际意义，能
否去掉方法的执行语句呢？

如果去掉父类的方法，就失去了多态的特性。
可以把父类的方法声明为抽象方法

public abstract class Person {
public abstract void run(); 
}
public class Student extends Person{
@Override
public void run() { …… }; 
…… 
}
public class Teacher extends Person{
@Override
public void run() { …… }; 
…… 
}

抽象方法

抽象方法没有任何执行语句；
• 因为无法执行抽象方法，因此类
也必须声明为抽象类（abstract
class）；
• 无法实例化一个抽象类。

无法实例化的抽象类的作用

• 抽象类用于被继承
• 抽象类可以强迫子类实现其定义
的抽象方法（否则编译错误）
• 抽象方法实际上相当于定义了“
规范

public abstract class Person {
public abstract void run(); 
}
Person p = new Person(); // 编译错误
Person s = new Student(); //正常
Person t = new Teacher(); //正常
//调用抽象方法实现多态;
s.run();
t.run();
}

面向对象编程的本质：

• 上层代码只定义***规范***（abstract
class Person） • 不需要子类就可以实现业务逻辑（正常编译）

• 具体的业务逻辑由不同的子类
实现，调用者并不关心。

抽象类

1.抽象方法定义了子类，必须实现的接口规范；

2.定义了抽象方法的类，就是抽象类；

3.从抽象类继承的子类，必须实现抽象方法；
4.如果不实现抽象方法，，则该子类仍然是一个抽象类。

接口

•如果一个抽象类没有字段，所有方法全部都是抽象方法，就可以把该抽象类改写为接口（interface）

• 使用 interface 声明一个接口

• 接口定义的方法默认是 public abstract（不需要写）

public interface Person {
public abstract void run(); 
}
public class Student implements Person{
@Override
public void run() { …… }; 
…… 
}
public class Teacher implements Person{
@Override
public void run() { …… }; 
…… 
}

• interface是Java内置的纯抽象接口
• 实现interface使用implements
• 可以实现多个interface，相当于多
继承（java是单继承方式）

public interface Hello {
String hello();
String goodbye(); 
}
public class Person implements Hello{
…… 
}
public class Robet implements Hello,Comparable{
…… 
}

局部内部类和成员内部类

局部内部类就是在局部函数里面定义的，

成员内部类就是类的成员变量。
抽象类不能实例化

接口：

类的构造器（构造方法）

类似构造函数

constructor

与C++构造函数一样，考研传参数


**

关于类图

**

异常