Java复习总结二
Java复习一：Java复习总结一
Java复习二：Java复习总结二
Java复习三：Java复习总结三
202402150378 许景程
一、面向对象程序设计(基础)
1.1面向对象的特性
封装、继承、多态是面向对象的三大特性。
1、封装：封装是指将对象的状态信息（属性）和行为（方法）隐藏在对象内部，只通过定义好的接口（公共方法）来访问对象的属性。
2、继承：继承是子类继承父类的特征和行为。子类可以在继承的基础上添加新的属性和方法，或者重写父类的方法。这就像子女会继承父母的某些特征，同时也有自己的个性一样。
3、多态：多态是指同一种行为（方法）在不同的对象上有不同的表现形式。简单说，就是一个方法调用根据对象的实际类型不同而执行不同的操作。
1.2 类和对象
类（设计图）：是对象的共同描述特征
对象：真正存在的具体实例
如何定义类：
public class 类名 {
1、成员变量（代表属性，一般是名词）
2、成员方法（代表行为，一般是动词）
3、构造器
4、代码块
5、内部类
}
如何使用类构造对象：类名 对象名 = new 类名( )；
1.3 类的定义
定义：在一个java文件中可以定义多个class类，但只能有一个类是public修饰的，并且public修饰的类名必须是文件名，实际开发中还是建议一个文件定义一个class类.
1.4 成员变量默认值
成员变量的完整定义格式是：修饰符 数据类型 变量名 = 初始化值，一般无需给值
| 数据类型 | 默认值 |
|---|---|
| 整型(short、byte、int、long) | 0 |
| 浮点型(float、double) | 0.0 |
| 字符型 | ‘\u0000’ |
| 布尔型 | false |
| 引用类型 | null |
1.5 构造方法
1.5.1 什么是构造方法
定义： 构造方法(构造器)，用于给对象进行初始化操作，即为对象成员变量赋初始值。
构造方法的名称必须与类型相同，并且不能定义返回值，不能出现 return 关键字。
构造方法的调用必须通过 new 关键字调用，语法格式如下
修饰符 类名(形参列表) {}
public class Constructor {
public static void main(String[] args) {
// 无参构造创建对象
Student student1 = new Student();
// 有参构造创建对象
Student student2 = new Student("张三", 23);
}
1.5.2 构造方法的重载
重载：方法名相同，与返回值类型无关(构造方法没有返回值)，只看参数列表
构造方法注意事项：
* 1、如果我们没有给出构造方法，系统将自动提供一个无参构造方法。
* 2、如果我们给出了构造方法，系统将不再提供默认的无参构造方法。
- 注意：这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法
1.6 this关键字
1.6.1 this
在Java中this关键字用于表示当前对象的引用。它可以用于访问和操作当前对象的属性和方法在方法内部，可以使用this关键字来显式地引用当前对象。
1.6.2 用法
引用当前对象的实例变量
public class This {
public static void main(String[] args) {
Point p1 = new Point(3, 5);
Point p2 = new Point(6, 1);
double length = p1.calcLength(p2);
System.out.println("两个坐标的距离为：" + length);
}
1.7 static关键字
1.7.1 静态变量
在类中，与成员变量同级的用static 修饰的变量称为 静态变量或类变量。
当想调用静态变量时，可以使用 对象名.变量名 调用，但不推荐，建议用 类名.变量名 调用
public class Static {
public static void main(String[] args) {
Student s1 = new Student();
Student s2 = new Student();
s1.grade = "计科2班";
System.out.println("s1的grade值：" + s1.grade);
System.out.println("s2的grade值：" + s2.grade);
System.out.println("使用类名取grade值：" + Student.grade);
}
}
1.7.2 静态方法
在Java中被static修饰的成员方法称为成员方法，是类的方法不是某个对象所特有的，静态成员一般通过静态方法来访问。
静态方法不属于某个具体的对象，是类方法。可以通过对象调用，但一般通过 类名.静态方法名()的方式调用。在静态方法中不能访问非静态成员变量，也不能访问任何非静态方法，因为非静态方法中有this参数，在静态方法中调用时候无法传递this引用。
二、面向对象程序设计(进阶)
1.封装
封装：是指隐藏对象的属性和实现细节，仅对外提供公共的访问方式。封装能够在一定程度上提高代码的安全性和复用性，使用时只需要了解使用方式，不需要知道内部细节。
| 修饰类 | 同一个类 | 同一个包 | 子 类 | 所有类 |
|---|---|---|---|---|
| private | √ | |||
| 默认(无修饰符) | √ | √ | ||
| protected | √ | √ | √ | |
| public | √ | √ | √ | √ |
private:表示私有，被它修饰的方法、变量只能被当前类访问
无修饰符:表示默认，被它修饰的方法、变量只能被当前包下的类访问
protected:表示受保护，被它修饰的方法、变量可以被当前包下所有的类，以及他包下的子类访问到.
public:表示公开的，被它修饰的方法、变量可以被当前项目下的所有类访问
1.1 get() / set() 方法
- get(): get方法用于取数据，所以要从内部返回值给属性。假设要获取名字信息
public String getName () {
return name;
}
返回数据为name，内向外赋值。
- set()：set方法用于设置数据，使用要从外部赋值给属性。假设要设置一个菜品价格：
public void setPrice (double price) {
this.price = price ;
}
外部传值给有参构造器，然后赋值给当前对象price。
2.继承
定义： 继承（extends 关键字）是面向对象的另外一个基本概念，利用继承，可以基于已存在的类构造一个新类，现有类被称作父类，新类称为子类，子类拥有父类所有的属性和方法，还可以拥有自己独特的属性和方法。
class 父类 {
}
class 子类 extends 父类{
}
注意：
1.如果没有一个类继承任何类，那么会默认继承 java.lang.Object
2.java类中之间只有单继承，因此一个子类只有一个直接父类
2.1 父类成员访问
1、子类中访问父类成员变量
在子类中可以直接使用父类的成员变量，当子类中存在与父类相同的成员变量时优先访问自己的成员变量，成员变量访问遵循就近原则，自己有就优先访问自己的，如果没则在父类中找，如果父类中也没有就会编译报错。
2、子类中访问父类成员方法
当成员方法没有同名时在子类方法中或者通过子类对象访问方法时，会优先访问自己的，如果自己没有就会到父类中找，父类中要是同样没有，就会编译报错。
3. super 关键字
super 可以理解为直接父类对象的引用，或者说super 指向子类对象的父类对象存储空间。可以通过super 访问父类中被子类覆盖的方法或属性。
super关键字只能在非静态方法中使用，在子类中访问父类的成员变量和方法。
super和this关键字的对比
| 区别 | this | super |
|---|---|---|
| 引用 | this代表本类对象的引用 | super代表父类存储空间 |
| 使用方式 | this.属性，this.方法，this() | super.属性，suiper.方法()，super() |
| 调用构造方法 | 调用本类构造方法，放在第一条语句 | 调用父类构造方法，放在第一条语句 |
| 查找范围 | 先从本类找，若找不到，则找父类 | 直接找父类 |
4. final 关键字
final 是一个修饰符，它可以用来修饰类、类中的属性和方法以及局部变量，但是不能修饰构造方法。主要用法如下：
- final修饰的类不可以被继承，但是可以继承其他类
- final修饰的方法不可以重写
- final修饰的变量是常量，只能被赋值一次
- final修饰的引用类型变量不能改变它的引用地址，但是可以改变对象内部属性的值
5. Object 类
Object类是java.lang包下的核心类，Object类是所有类的父类，何一个类时候如果没有明确的继承一个父类的话，那么它就是Object的子类；
Object 类属于java.lang包，此包下的所有类在使用时无需手动导入，系统会在程序编译期间自动导入
Object类的常用方法：
| 方法签名 | 方法描述 |
|---|---|
| String toString() | 返回该对象的字符串表示形式 |
| boolean equals(Object obj) | 判断两个对象的地址是否相同 |
| native int hashCode() | 返回该对象的哈希值 |
- toString方法
toString()：取得对象信息，返回该对象的字符串表示
public class ToString {
public static void main(String[] args) {
People people = new People();
people.setName("张三");
people.setAge(23);
Teacher teacher = new Teacher();
teacher.setName("李四");
teacher.setAge(24);
Worker worker = new Worker();
worker.setName("王五");
worker.setAge(25);
String peopleStr = people.toString();
System.out.println(peopleStr);
System.out.println(teacher.toString());
System.out.println(worker);
}
}
2.equals方法
equals()：对象比较
public class Equals {
public static void main(String[] args) {
People p1 = new People();
p1.setName("张三");
p1.setAge(23);
People p2 = new People();
p2.setName("张三");
p2.setAge(23);
People p3 = new People();
p3.setName("李四");
p3.setAge(24);
// == 比较的是地址，p1和p2是两个对象，地址不同
System.out.println("p1 == p2：" + (p1 == p2));
System.out.println("p1 equals p2：" + p1.equals(p2));
System.out.println("p1 equals p3：" + p1.equals(p3));
}
}
6. 多态
多态是面向对象的三大特性之一，指的是同一个方法调用，由于对象不同可能会有不同的行为。多态的前提是必须存在继承，并且子类重写了父类的方法，最重要的是父类引用要指向子类对象。
1.向上转型：父类引用指向子类对象，属于自动类型转换。格式：
父类类型 变量名 = 子类对象；
2.向下转型：子类引用指向父类对象，属于强制类型转换。格式：
子类类型 变量名 = (子类类型) 父类对象；
7.抽象类
抽象类是在普通类上新增的特殊类。抽象的关键字是 abstract，语法格式如下：
权限修饰符 abstract class 类名{ }
权限修饰符 abstract 返回值类型 方法名 (参数列表)；
注意以下5点：
- 抽象方法只有方法声明，没有方法体，它必须交给子类重写。 子类重写抽象方法，也称为“实现”抽象方法。
- 子类如果也有抽象类，则不一定需要实现父类的抽象方法，而如果不是抽象类，则必须实现父类中所有的抽象方法。
- 抽象方法必须被子类重写，因此抽象方法的访问修饰符不能是 private。
- 由于抽象方法没有具体的方法体，无法用一个抽象的对象调用它，因此抽象类不能被实例化
- 抽象类可以有构造方法，它的构造方法的作用是便于子类创建对象时给抽象类的属性赋值。
8.接口
定义：接口可以理解为一种特殊的类，里面全部是由全局常量和公共的抽象方法所组成。
接口是解决Java无法使用多继承的一种手段，但是接口在实际中更多的作用是制定标准的。或者我们可以直接把接口理解为100%的抽象类，既接口中的方法必须全部是抽象方法。（JDK1.8之前可以这样理解）
接口的关键字用 interface 修饰，格式如下：
interface 接口名 [extends 父接口1，父接口2，…]{
//常量定义
//方法定义
}
定义接口所在的文件仍然是 .java 文件，编译后仍然会产生 .class 文件，可以将接口看作一个语法比较特殊的类。
8.1 接口的多实现
Java中类与类之间只能单继承，但是类与接口之间却允许有多实现，当一个类实现了多个接口时，只能用逗号将这些接口隔开即可，如下：
class 类 inplements 接口1，接口2{ }；
8.2 接口的继承
如同类之间允许继承一样，接口也允许继承，并且接口之间的继承允许多继承。
public interface USB2 extends USB{
void slowTransfer();
}
8.3 接口的static方法 和 default 方法
接口所有方法默认都是public修饰的，static和default 方法也一样，格式如下：
public interface 接口{
static void method1() {
}
default void method2() {
}
}
9. 内部类
定义：即一个类的内部又完整的嵌套了另一个类结构，被嵌套的类称为内部类(inner class)。
9.1 成员内部类
成员内部类特点：
1.成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）；
2.同名的属性名/方法名访问外部类时 → 外部类.this.成员名
class 外部类{
修饰符 class 内部类{
}
}
9.2 静态内部类
静态内部类特点：
1.静态内部类也是定义在另一个类里面的类，只不过在类的前面多了一个关键字static;
2.静态内部类是不需要依赖于外部类的，这点和类的静态成员属性有点类似，并且它不能使用外部类的非static成员变量或者方法;
3.静态内部类中即能声明静态成员也可以声明非静态成员。
class 外部类{
修饰符 static class 内部类{
}
}
9.3 局部内部类
局部内部类的特点：
1.局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内；
2.局部内部类不可使用权限修饰符 静态(static)修饰符进行修饰 同局部变量相同；
3.局部内部类可以直接访问方法中的属性；
4.局部内部类 可以直接访问方法外部类中属性和方法；
5.局部内部类 创建对象 要在方法内部 局部内部类的外部声明。
class 外部类{
修饰符 返回值 方法名(参数列表){
class 内部类{
//代码
}
}
}
9.4 匿名内部类
匿名内部类特点：
匿名内部类不能定义任何静态成员、方法和类，只能创建匿名内部类的一个实例。一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。
new 接口() | 父类() {
//代码
}
总结
-
面向对象编程是 Java 的核心，具有封装、继承、多态三大特性。类是对象的设计图，可定义成员变量、方法等，构造器用于初始化对象。this 表示当前对象引用，static 用于静态变量和方法。封装通过修饰符控制访问权限，get/set 方法方便操作属性。继承通过 extends 实现，子类可拥有父类特性，super 访问父类元素。final 修饰类、方法和变量有不同限制。Object 类是根类，有重要方法。多态需继承和重写，涉及向上向下转型。抽象类含抽象方法，不能实例化。接口可多实现和继承，含 static 与 default 方法。内部类包括成员、静态、局部和匿名内部类，各有特点。
-
这些概念构建了 Java 强大的面向对象体系，使代码结构更清晰、易维护和扩展。合理运用可提高开发效率，但需注意如构造器重载、多态转型的细节，避免混淆。内部类增加了代码组织的灵活性，但要注意其使用场景和限制，以免影响代码可读性和性能。掌握好它们是 Java 编程的关键，需要不断实践才能熟练运用。
扫一扫
1626
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
