java面向对象复习（详细知识点）

源创可可

已于 2024-08-29 15:58:20 修改

阅读量1.3k

点赞数 44

文章标签： java

于 2024-08-29 13:50:05 首次发布

本文链接：https://blog.csdn.net/m0_58881902/article/details/139205972

版权

项目一方法的定义与应用

定义方法

知识储备

概述：

JAVA类的其中一个成员就是方法（函数），方法是一个独立的功能模块；
类中可以有多个方法，其中main方法（主方法)最多只能有一个，是程序执行的入口；
利用“方法”可以实现代码复用（可以多次调用)，使程序结构清晰。

方法定义的形式：

[修饰符] [方法类型] [方法名]（[形参类型形参名, ...]）{
声明部分；
语句部分；
}

public int calculateSum(int number1, int number2) {
    int sum; // 声明部分

    sum = number1 + number2; // 语句部分
    return sum; // 返回计算结果
}

说明：

方法类型：方法返回值的类型；如果没有返回值，类型为void
形参：形式参数，是方法的“输入”。
声明部分：包括变量、数组的定义等
语句部分：是方法功能的实现。
方法的返回值：是方法的“输出”，返回给方法调用。实现形式：return表达式；如果方法类型是void,则没有return语句或return

例题：

定义方法实现1+2+3+...+n：

static int getsum1(int n){
    int i;
    int sum =0;
    for（i=1;i<=n;i++){
         sum+=i;
    }
    return sum;
}

定义方法实现1- $\frac{}{}$ $\frac{1}{2}$ + $\frac{1}{3}$ - $\frac{1}{4}$ ...+ $\frac{1}{n}$ ：

static double getsum3(int n){
    double sum = 0;
    int sign = 1;
    for(int i = 1;i <= n; i++){
        sum += sign * 1.0/i
        sign * = -1;
     }
     return sum;
}

实操

package b;

public class qiuhe {
	public static void main(String[] args) {
		double result = sum(1e-4); // 调用sum方法并传入阈值10^-4
		System.out.println("Sum: " + result);
	}// 打印结果

	static double sum(double limit) {
		double sum = 0.0; // 初始化数列和为0
		double term = 1.0; // 初始化通项为1
		int denominator = 1; // 分母初始化为1
		// 循环直到通项小于limit
		while (term >= limit) {
			sum += term; // 将通项加到数列和中
			denominator++; // 分母加1
			term = 1.0 / denominator; // 计算下一个通项
		}
		return sum;// 返回数列和
	}
}
// 类的其余部分（如果有的话）... }

import java.util.Scanner;

public class sad {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.print("请输入一个正整数：");
		int n = sc.nextInt();
		System.out.print("当n=" + n + "时，");
		System.out.println("数列的和为：" + sum(n));
		sc.close();// 关闭Scanner对象以释放资源
	}

	public static double sum(int n) {
		double sum = 0.0; // 将变量名从result改为sum
		for (int i = 1; i <= n; i++) {
			sum += Math.pow(-1, i - 1) * (1.0 / i);
		}
		return sum; // 返回计算得到的和
	}
}

调用方法和传递参数

知识储备

形式：

方法名（实参1，实参2，…)

说明：
方法调用时实参要与形参一一对应。

非静态方法：

需要通过类的实例调用
方法调用可以放在表达式里
输出调用
作为另一个方法调用的实参调用

静态方法：

可以通过类名直接调用，不需要创建类的实例。
方法调用可以放在表达式中，也可以作为其他方法调用的实参printDouble(getStaticNumber())。

注：无返回值的方法只能单独作为一条语句，不能放在表达式中或者输出语句里。

示例：

非静态方法的调用：【只能通过对象调用（对象名.方法名）】

public class MyClass {
    // 非静态方法，有返回值
    public int getNumber() {
        return 5;
    }

    // 非静态方法，无返回值
    public void printMessage() {
        System.out.println("Hello, World!");
    }

    public static void main(String[] args) {
        MyClass obj = new MyClass();  // 创建类的实例

        // 调用非静态方法，有返回值
        int result = obj.getNumber();  // 可以用在表达式中
        System.out.println(result);    // 输出结果

        // 调用非静态方法，无返回值
        obj.printMessage();            // 只能作为单独的语句

        // 错误：不能将void方法放在表达式中
        // int result2 = obj.printMessage();  // 编译错误
        // System.out.println(obj.printMessage());  // 编译错误
    }
}

静态方法的调用：【可以直接调用，类名调用和对象调用（类名.方法名 / 对象名.方法名）】

public class MyClass {
    // 静态方法，有返回值
    public static int getStaticNumber() {
        return 10;
    }

    // 静态方法，无返回值
    public static void printStaticMessage() {
        System.out.println("Static Hello, World!");
    }

    public static void main(String[] args) {
        // 调用静态方法，有返回值
        int result = MyClass.getStaticNumber();  // 可以用在表达式中
        System.out.println(result);              // 输出结果

        // 调用静态方法，无返回值
        MyClass.printStaticMessage();            // 只能作为单独的语句

        // 错误：不能将void方法放在表达式中
        // int result2 = MyClass.printStaticMessage();  // 编译错误
        // System.out.println(MyClass.printStaticMessage());  // 编译错误
    }
}

参数传递方式一一单向值传递：

方法调用时，先计算实参的值
将此值传递给（赋给）形参
形变实不变

注：不同方法内的变量名可以是相同的没有返回值的方法调用不参与运算

变量作用域：
全局变量：
在方法以外定义。
作用域是整个类。
局部变量：
在方法内部或复合语句内部定义·
作用域是本方法或复合语句内。

值类型和引用类型

值类型变量存放的是数据本身

 // 值类型示例（基本数据类型）
        int a = 10;
        int b = a;  // b 是 a 的一个副本
        b = 20;     // 修改 b 的值，不会影响 a
        System.out.println("a: " + a); // 输出: a: 10
        System.out.println("b: " + b); // 输出: b: 20

引用类型变量存放的是数据的引用(即地址）

  // 引用类型示例（对象类型）
        int[] array1 = {1, 2, 3};
        int[] array2 = array1;  // array2 引用的是 array1 的地址
        array2[0] = 10;         // 修改 array2 的内容，也会影响 array1
        System.out.println("array1[0]: " + array1[0]); // 输出: array1[0]: 10
        System.out.println("array2[0]: " + array2[0]); // 输出: array2[0]: 10

实操

1.判断一个字符是不是数字

public class Main {
    public static void main(String[] args) {
        char ch = '7'; // 示例字符
        if (isDigital(ch)) {
            System.out.println("是");
        } else {
            System.out.println("否");
        }
    }

    // 判断字符是否为数字的方法
    public static boolean isDigital(char ch) {
        // 检查字符ch是否在'0'到'9'的范围内
        return ch >= '0' && ch <= '9';
    }
}

2.判断一个数是否是偶数

public class EvenNumberChecker {

    // 判断一个数是否是偶数的方法
    public static boolean isEven(int number) {
        // 如果number除以2的余数为0，那么number是偶数
        return number % 2 == 0;
    }

    public static void main(String[] args) {
        // 测试isEven方法
        int testNumber = 4;
        if (isEven(testNumber)) {
            System.out.println(testNumber + "是偶数。");
        } else {
            System.out.println(testNumber + "不是偶数。");
        }
    }
}

3.判断一个字符是否是大写/小写/字母

	public static boolean IsUpper(char ch) {
		return ch >= 'A' & ch <= 'Z';
	}//大写
    /* 这里省略了其他步骤 */

public static boolean IsLower(char ch) {
		return ch >= 'a' & ch <= 'Z';
	}// 小写

public static boolean IsChar(char ch) {
		return ch >= 'a' && ch <= 'z' || ch >= 'A' & ch <= 'Z';
	}//字母

方法重载

知识储备

同一个类中，方法名相同
形参类型、形参个数不同
不包括：方法返回值类型和形参名称

实操

public class Main {
    public static void main(String[] args) {
        System.out.println("3 + 7 = " + add(3, 7));
        System.out.println("3 + 5 + 9 = " + add(3, 5, 9));
        System.out.println("3 + 7 + 5 + 9 + 1 = " + add(3, 7, 5, 9, 1));
        System.out.println("2.5 + 7.1 = " + add(2.5, 7.1));
    }

    // 求两个整数之和
    static int add(int a, int b) {
        return a + b;
    }

    // 求三个整数之和
    static int add(int a, int b, int c) {
        return a + b + c;
    }

    // 求任意多个整数之和
    static int add(int... a) {
        int sum = 0;
        for (int num : a) {
            sum += num;
        }
        return sum;
    }

    // 求两个小数之和
    static double add(double a, double b) {
        return a + b;
    }
}

项目二类的识别与封装

初识面向对象

知识储备

面向：拿、找
对象：能干活的东西
面向对象编程：拿东西过来做对应的事情

面向对象三个基本原则：封装、继承、多态

定义类和创建对象

知识储备

类（设计图）：是对象共同特征的描述;
对象：是真实存在的具体东西。

在Java中，必须先设计类，才能获得对象

定义类：

public class 类名{
1、成员变量（代表属性的，一般是名词）
2、成员方法（代表行为的，一般是动词）}

public class Phone{
//属性 (成员变量)
String brand;
double price;
//行为 (方法)
public void call(){
}
public void playGame(）{
{
}

注意事项：

类名首字母建议大写，需要见名知意，驼峰模式。
一个Java文件中可以定义多个class类，且只能一个类是public修饰，而且public修饰的类名必须成为代码文件名。实际开发中建议还是一个文件定义一个class类。
成员变量的完整定义格式是：修饰符数据类型变量名称=初始化值；一般无需指定初始化值，存在默认值。

创建对象：

类名对象名 = new 类名();
Phone p = new Phone();

拿到对象之后可以：

对象.成员变量；
对象.成员方法(...）

this关键字：

public class GirlFriend{
	//属性
	private int age;//o
	public void method(){
	int age = 10;
	System.out.println(age);//谁离我近，我就用谁
	System.out.println(this.age);//成员变量
	}
}

修饰符：

访问修饰符：
- public：方法可以被任何其他类访问。
- protected：方法可以被同一个包中的类和不同包中的子类访问。
- private：方法只能在定义它的类内部访问。
- default（没有指定时的访问级别）：方法只能被同一个包中的类访问。
非访问修饰符：
- static：静态方法可以在没有创建类的实例的情况下被访问，它属于类而不是类的实例。
- final：最终方法不能被子类覆盖。
- abstract：抽象方法必须在抽象类中声明，并且必须由子类实现。
- synchronized：同步方法确保多个线程在同一个时刻只能有一个线程执行该方法。
- native：本地方法在Java外部实现，通常是用C或C++编写的。

实操

设计Student类：定义相应的字段和方法。要求：1）在主类中创建Student 类的对象；2）通过该对象调用实例方法，设置该Student对象的各个字段，并打印显示该对象信息。

public class Student {
    // 私有字段
    private String id;    // 学号
    private String name;  // 姓名
    private int age;      // 年龄

    // 公有方法：设置学号
    public void setId(String id) {
        this.id = id;
    }

    // 公有方法：设置姓名
    public void setName(String name) {
        this.name = name;
    }

    // 公有方法：设置年龄
    public void setAge(int age) {
        this.age = age;
    }

    // 公有方法：获取学号
    public String getId() {
        return id;
    }

    // 公有方法：获取姓名
    public String getName() {
        return name;
    }

    // 公有方法：获取年龄
    public int getAge() {
        return age;
    }

    // 公有方法：生成对象信息字符串
    @Override
    public String toString() {
        return "Student{id='" + id + "', name='" + name + "', age=" + age + "}";
    }

    // 主方法，用于创建 Student 对象并展示其信息
    public static void main(String[] args) {
        Student student = new Student();
        student.setId("2024001");
        student.setName("张三");
        student.setAge(20);

        System.out.println("学号: " + student.getId());
        System.out.println("姓名: " + student.getName());
        System.out.println("年龄: " + student.getAge());

        // 打印 Student 对象的字符串表示
        System.out.println(student.toString());
    }
}

使用实例构造函数

知识储备

构造函数：

1、它是类的一种特殊方法，方法名与类名相同（大小写也要一致）
2、没有返回类型，连void都没有
3、可以重载。带参构造方法，和无参数构造方法，两者方法名相同，但是参数不同，这叫做构造方法的重载
4、不允许用户显式地直接调用，只能紧跟new之后调用
5、在创建实例对象时，系统自动调用该类的构造函数为新对象初始化
6、若用户未定义任何构造函数，系统将为这个类缺省定义一个空构造函数，
形式如下:
public 类名（）{}
7、若用户定义了构造函数，则系统将不再提供缺省的构造函数
8、也叫构造方法、构造器

无论是否使用，都手动书写无参数构造方法，和带全部参数的构造方法

标准的bean类：

①类名需要见名知意
②成员变量使用private修饰
③提供至少两个构造方法

无参构造方法
带全部参数的构造方法

④成员方法
提供每一个成员变量对应的setXxx()/getXxx()
如果还有其他行为，也需要写上

实操

设计平面直角坐标系下的Point类：定义相应的字段和方法。要求：在主方法中创建两个Point类的对象，调用各方法完成设置两点坐标、计算两点间距离、屏幕打印点坐标信息等功能。

public class Point {
    // 私有字段：x 和 y 坐标
    private int x;
    private int y;

    // 无参构造方法：构造成坐标原点
    public Point() {
        this.x = 0;
        this.y = 0;
    }

    // 有参构造方法：构造成指定坐标
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    // 设置x坐标
    public void setX(int x) {
        this.x = x;
    }

    // 设置y坐标
    public void setY(int y) {
        this.y = y;
    }

    // 设置点的坐标
    public void setPoint(int x, int y) {
        this.x = x;
        this.y = y;
    }

    // 设置点的坐标（使用另一个Point对象）
    public void setPoint(Point other) {
        this.x = other.x;
        this.y = other.y;
    }

    // 获取x坐标
    public int getX() {
        return x;
    }

    // 获取y坐标
    public int getY() {
        return y;
    }

    // 计算距离另一个点的距离
    public double distanceTo(Point other) {
        int dx = this.x - other.x;
        int dy = this.y - other.y;
        return Math.sqrt(dx * dx + dy * dy);
    }

    // 计算距离坐标原点的距离
    public double distanceTo() {
        return Math.sqrt(x * x + y * y);
    }

    // 生成对象信息字符串
    @Override
    public String toString() {
        return "Point{" + "x=" + x + ", y=" + y + '}';
    }

    // 主方法，用于测试 Point 类
    public static void main(String[] args) {
        // 创建两个 Point 对象
        Point p1 = new Point(3, 4);
        Point p2 = new Point(6, 8);

        // 打印点的坐标信息
        System.out.println("点1: " + p1.toString());
        System.out.println("点2: " + p2.toString());

        // 设置点的坐标
        p1.setX(5);
        p1.setY(7);
        System.out.println("更新后点1: " + p1.toString());

        // 计算两点间距离
        double distance = p1.distanceTo(p2);
        System.out.println("点1与点2之间的距离: " + distance);

        // 计算点1到坐标原点的距离
        double distanceToOrigin = p1.distanceTo();
        System.out.println("点1到原点的距离: " + distanceToOrigin);
    }
}

项目三类继承和多态的实现

实现类的继承和子类构造函数

知识储备

概念：

继承是指从现有类（基类、父类、超类）中派生出新类（派生类、子类）的过程
子类自动地包含父类中的全部字段和方法（构造函数除外）
可以在子类中增加新的字段和方法，或修改所继承的字段和方法

继承的特点：子类能继承父类的非私有成员（成员变量、成员方法)。
继承后对象的创建：子类的对象是由子类、父类共同完成的。

注意：

Java是单继承的：一个类只能继承一个直接父类；Java中的类不支持多继承，但是支持多层继承。
Object类是java中所有类的祖宗

定义子类：

class 子类名 extends 父类名
{
子类字段
子类方法
}

方法重写：

当子类觉得父类中的某个方法不好用，或者无法满足自己的需求时，子类可以重写一个方法名称、
参数列表一样的方法，去覆盖父类的这个方法，这就是方法重写。
注意：重写后，方法的访问，Java会遵循就近原则。

技巧：

使用Override注解，他可以指定java编译器，检查我们方法重写的格式是否正确，代码可读性也会更好。
子类重写父类方法时，访问权限必须大于或者等于父类该方法的权限(public>protected>缺省)。
重写的方法返回值类型，必须与被重写方法的返回值类型一样，或者范围更小。
私有方法、静态方法不能被重写，如果重写会报错的。

示例：

public class A {
public void print1(){
System.out.println("111);
}
public void print2(int a,int b){
System.out.println("111111");
}

public class B extends A{
//方法重写

@Override
public void print1(){
System.out.println("666");
}
//方法重写

@Override
public void print2(int a,int b){
System.out.println("666666");
}

子类访问的特点：

在子类方法中访问其他成员（成员变量、成员方法)，是依照就近原则的。

可以通过super关键字，指定访问父类的成员：super.父类成员变量/父类成员方法

子类构造器的特点：

子类的全部构造器，都会先调用父类的构造器，再执行自己。

默认情况下，子类全部构造器的第一行代码都是supr()(写不写都有)，它会调用父类的无参数构造器。
如果父类没有无参数构造器，则我们必须在子类构造器的第一行手写supr(.…),指定去调用父类的有参数构造器。

示例：

this(.…)调用兄弟构造器：

任意类的构造器中，是可以通过this(…)去调用该类的其他构造器的。

实操

设计一个Shape2D类、Circle类、Rectangle类、Square类。Circle类、Rectangle类继承Shape2D类，Square类继承Rectangle类

public class Test {
	public static void main(String[] args) {
		Shape2D[] shape = new Shape2D[] { new Rectangle(2, 3), new Square(10), new Circle(5) };
		for (Shape2D s : shape) {
			System.out.println(s);
			System.out.printf("我的面积=%.2f\n", s.getArea());

		}
	}
}
public class Shape2D {
	public double getArea() {
		return 0.0;
	}
}
public class Circle extends Shape2D {
	private int radius;

	public Circle(int radius) {
		if (radius > 0) {

			this.radius = radius;
		}
	}

	@Override
	public double getArea() {
		return Math.PI * radius * radius;
	}

	@Override
	public String toString() {
		return "我是一个圆形";
	}
}
public class Rectangle extends Shape2D {

	private int length;
	private int width;

	public Rectangle(int length, int width) {
		if (length > 0) {
			this.length = length;
		}
		if (width > 0) {
			this.width = width;
		}
	}

	@Override
	public double getArea() {
		return length * width;
	}

	@Override
	public String toString() {
		return "我是一个长方形";
	}
}
public class Square extends Rectangle {
	public Square(int side) {
		super(side, side);
	}

	@Override
	public String toString() {
		return "我是一个正方形";
	}
}

抽象类和接口

知识储备

抽象类:

abstract修饰类，这个类就是抽象类；修饰方法，这个方法就是抽象方法。

public abstract class A {
//抽象方法：必须abstract修饰，只有方法签名，不能有方法体。
public abstract void test();

}

特点:

抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类。
类该有的成员（成员变量、方法、构造器)抽象类都可以有。
抽象类最主要的特点：抽象类不能创建对象，仅作为一种特殊的父类，让子类继承并实现。
一个类继承抽象类，必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类。
抽象类可以有构造函数（只是为了初始化字段）
抽象类也可以继承非抽象类
抽象类也可以实现接口

好处:

父类知道每个子类都要做某个行为，但每个子类要做的情况不一样。父类就定义成抽象方法，交给子类去重写实现，我们抽出这样的抽象类，就是为了更好的支持多态。

对抽象类和抽象方法的限制
(1)构造函数不能是抽象的
(2)定义为static、final或private的方法不能是抽象的
(3)最终类(final)不能同时为抽象类

示例：

某宠物游戏，需要管理猫、狗的数据。
猫的数据有：名字；行为是：喵喵喵的叫~
狗的数据有：名字；行为是：汪汪汪的叫~

接口

public interface 接口名{
//成员变量（常量）
//成员方法（抽象方法）

}

接口可视为特殊的抽象类，它由常量和抽象方法组成，不能被实例化。

接口中的常量——隐含为public static final,必须初始化，方法——隐含为public abstract

接口采用多重继承机制，即接口可以同时继承多个接口。用途：将多个接口组合成一个接口

一个类只能继承一个父类，但可以同时实现多个接口，这样可以达到多重继承的效果(extends要放在implements之前)

接口不能创建对象；接口是用来被类实现(implements)的，实现接口的类称为实现类。

修饰符 class 实现类 implements 接口1,接口2,接口3,...{

}

实现类实现多个接口，必须重写完全部接口的全部抽象方法，否则实现类需要定义成抽象类。

好处：

因为通过接口去找干爹，别人通过你implements的接口，就可以显性的知道你是谁，从而也就可以放心的把你当作谁来用了。
一个类我们说可以实现多个接口，同样，一个接口也可以被多个类实现的。这样做的好处是我们的程序就可以面向接口编程了，这样我们程序员就可以很方便的灵活切换各种业务实现了。

实操

编写一个程序完成以下接口和类：

项目四程序的异常处理

认识异常和异常处理

知识储备

异常是把代码中的错误传递给调用方代码的一种特殊手段。如果在一个子程序中遇到了预料之外的情况，但不知道该如何处理的话，它就可以抛出一个异常。

抛出异常(throws）：

方法 throws 异常1，异常2，异常3 ..{

...

}

捕获异常(try..catch) :

try{
//监视可能出现异常的代码！
}catch(异常类型1变量){
//处理异常
}catch(异常类型2变量){
//处理异常
}…

自定义异常：

运行时

定义一个异常类继承RuntimeException
重写构造器。
通过throw new异常类(xxx)来创建异常对象并抛出。

编译阶段不报错，提醒不强烈，运行时才可能出现！

编译时

定义一个异常类继承Exception.
重写构造器。
通过throw new异常类(xx)来创建异常对象并抛出。

编译阶段就报错，提醒更加强烈！

示例：

保存一个合法的年龄

//必须让这个类继承自RuntimeException，才能成为一个运行时异常类
public class AgeIllegalRuntimeException extends RuntimeException {
	public AgeIllegalRuntimeException() {
	}

	public AgeIllegalRuntimeException(String message) {
		super(message);
	}
}


//必须让这个类继承自Exception，才能成为一个编译时时异常类
public class AgeIllegalException extends Exception {
	public AgeIllegalException() {
	}

	public AgeIllegalException(String message) {
		super(message);
	}
}

public class ExceptionTest2 {
	public static void main(String[] args) {
		// 需求：保存一个合法的年龄
		try {
			saveAge(160);
			System.out.println("底层执行成功");
		} catch (Exception e) {
			e.printStackTrace();
			System.out.println("底层出现bug!");
		}
		try {
			saveAge2(225);
			System.out.println("saveAge2底层执行是成功的！");
		} catch (AgeIllegalException e) {
			e.printStackTrace();
			System.out.println("saveAge2底层执行是出现bug的！");
		}
	}
    //编译时异常
	public static void saveAge2(int age) throws AgeIllegalException {
		if (age > 0 & age < 150) {
			System.out.println("年龄被成功保存：" + age);
		} else {
			// 用一个异常对象封装这个问题
			// throw 抛出去这个异常对象
			//throws 用在方法上，抛出方法内部的异常
			throw new AgeIllegalException("/age is illegal,your age is " + age);
		}
	}
    //运行时异常
	public static void saveAge(int age) {
		if (age > 0 & age < 150) {
			System.out.println("年龄被成功保存：" + age);
		} else {
			// 用一个异常对象封装这个问题
			// throw 抛出去这个异常对象
			throw new AgeIllegalRuntimeException("/age is illegal,your age is " + age);
		}
	}
}

实操

检验输入数据非法和超界[0,100]

import java.util.Scanner;

public class Test {
	public static void main(String[] args) {
		int n = 0;
		boolean flag = true;
		Scanner reader = new Scanner(System.in);
		while (flag) {
			System.out.print("n= ");
			try {
				n = reader.nextInt();
				if (n < 0 || n > 100) {
					throw new IllegalArgumentException();// 抛出异常
				}
				flag = false;
			} catch (IllegalArgumentException ex) {
				System.out.println("输入数据超界，请重新输入！");
			} catch (Exception ex) {
				System.out.println("输入数据非法，请重新输入！");
				reader.next();// 必须跳过非法数据
				System.out.println("n =" + n);
			}
		}
	}
}