# SUST_ObjectOrientedTechnology

**Repository Path**: salute83/sust_-object-oriented-technology

## Basic Information

- **Project Name**: SUST_ObjectOrientedTechnology
- **Description**: 苏州科技大学，面向对象技术代码及练习
- **Primary Language**: Unknown
- **License**: Apache-2.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 1
- **Forks**: 0
- **Created**: 2022-09-15
- **Last Updated**: 2022-12-02

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# 基础知识

# 方法

# String

# 数组

## 增强 for 循环

增强for循环在每次迭代中，通过一个变量来存储数组总连续的数组元素。

增强 for 循环适合遍历整个数组。以下情况才能使用增强for 循环：

1. 需要访问整个数组（不是数组的一部分）。
2. 需要读取数组中的元素，而不是修改。
3. 不需要使用数组下标完成其他处理。

如果修改数组元素则不适合使用 增强 for 循环。

**定义增强 for 循环**

```java
for(type a : arrays arr){
    ……
}
```

# 5 类与对象

## 类与对象的关系

**类和对象之间是抽象与具体的关系**。

类是对某一类事物的描述，是抽象、概念上的定义

对象是实际存在的某类十五的个体，也被称为实例。

类是在对象之上的抽象,对象则是类的具体化,是类的实例。

## 类

类是程序的基本单元。类将数据和方法和属性封装在一起。

**定义一个类**

```java
[修饰符] class 类名 {
	属性;
	方法;
}
```

> 1. 类名一般首字母大写
>2. 类的修饰符：权限访问修饰符
> 3. 一个Java文件中可以写多个类，但是只有一个类为public ，但是Java在编译的时候会根据类编译多个.class 文件

## 访问权限修饰符

在Java中，针对类、成员方法和属性提供了**四种访问级别，分别是private、default、protected和public**。

控制级别：

![Java访问级别](https://83-cloud-space.oss-cn-shenzhen.aliyuncs.com/File/Typora/202209151227352.jpeg)

![java访问级别](https://83-cloud-space.oss-cn-shenzhen.aliyuncs.com/File/Typora/202209151227735.png)

● private(当前类访问级别)：不能被该成员所在类之外的任何类访问。

● default(包访问级别)：在同一个包中的类可见。简单来说：对于同一个包中的类，权限相当于public ,对于不同包中的类，权限相当于private。

● protected(子类访问级别)：成员的访问权限相当于包加继承关系的子类。

● public(公共访问级别)：所有的其他类可以访问该成员。

> 访问权限修饰符不能用来修饰局部变量（方法内定义的变量），否则会报错。
>
> 且局部变量的作用域是局部的，也没有必要设置访问权限修饰符。

## 对象

创建对象使用new 关键字 和类名。

**创建对象语法**

```java
类名 对象名 = new 对象名([参数列表]);
```

> new 后面是调用的指定类中的构造方法。
>
> 当使用new 时候，表示在内存中开辟空间，空间大小根据具体类确定。
>
> 变量名存放在栈空间中，new 创建的对象存放在堆空间中，变量名指定对象在堆空间中的地址。

**匿名对象**

如果不把对象赋值给变量，直接调用对象的方法，称这样的对象叫做匿名对象。例如：`new Car().getColor();`

## 变量

Java的变量分为两种：

1. 成员变量：在类中声明，在类中的任何位置都可以被访问。
2. 局部变量：在方法的内部或者代码块中被声明，只能被该方法或者代码块内部访问，超出范文则无法访问。

> 当创建对象时候，虚拟机会自动为成员变量进行初始化，在程序中可以不对成员变量进行初始化。
>
> 局部变量在声明时不会赋默认值，局部变量必须初始化。
>
> 成员变量在堆空间中分配空间，局部变量在栈空间中分配空间。

## 构造方法

构造方法的作用是初始化成员变量。创建对象时会通过调用构造构造方法为对象的成员变量赋予初始值。

- 当构造方法没有参数时，Java虚拟机会自动给成员变量赋默认值。
- 当构造方法有参数时，将按照传递的参数初始化成员变量。

**创建构造方法语句**

```java
类名([参数列表]){
    ……
}
```

**构造方法的注意点**

1. 构造方法的方法名必须与类名相同。
2. 构造方法没有返回值，不需要加void修饰符，也不能使用return语句。
3. 构造方法的调用比较特殊，是在创建类的新对象时由系统自动调用该类的构造方法，且只能调用一次。
4. 在类中，如果不定义构造方法，系统会自动生成一个默认的无参构造方法。但是如果自定义了构造方法，系统默认的无参构造方法则不会自动生成。
5. 在一个类中可以定义多个构造方法，方法的名字相同，但是参数不同，这种情况叫方法的重载。

## this 关键字

在类中的类中，成员变量和方法形参如果同名，则有时会出现命名冲突的问题。可以使用this关键词来区分两种变量。

this 表示当前类，有三种用法：

### this 表示类的成员

```java
this.成员
```

> 成员可以是成员变量或者成员方法。

### this 调用构造方法

this 还可以调用构造方法，一个类可以有多个构造方法，多个重载的构造方法之间可以相互调用。调用时除了使用构造方法名进行调用外，还可以使用this关键字。

```java
this([参数列表]);		// ✔
this Car([参数列表]);   // ×
```

> 1. this 和 （） 之间不能有 . 也不能写出构造方法的名称。
> 2. 如果使用 this( )调用其他构造方法时，this( )调用必须是方法的第一句。
> 3. 在构造方法时候如果调用其他的构造方法，只能调用一次。
> 4. this( )调用不能出现在非构造方法中。

### this 表示当前对象

this 可以直接使用，表示当前对象。

**例如：**

```java
public void getInfo(){
    System.out.println(this);
}
```

> 当调用 getInfo( ) 方法时，哪个对象调用，哪个对象就是当前的对象。
>
> this 的值是当前对象的首地址。
>
> main 方法调用 p1.getInfo( )方法时，将输出 p1的首地址。main 方法调用 p2.getInfo( )方法时，将输出 p2的首地址。

## static 修饰符

用 static 关键字修饰的成员变量或者方法称为 静态成员（类成员），静态成员不依赖于某一个特定的对象。

系统会在实例化类的第一个对象时为静态成员分配内存。后续再实例化其他对象时，不再为静态成员分配内存空间。不同对象共享同一个静态成员。

### 静态变量

成员变量前用 static 修饰，成员变量就为静态变量（类变量）。

静态变量在内存中只存储一次，所有的实例对象都共享这一个内存空间。

类变量属于类，而不属于一个特定的对象，所以 静态变量可以用 “类名.类变量名” 来访问。类变量也可以通过“对象名.类变量名”来访问。

所有实例对象都共享类变量，无论哪个对象修改了类变量的值，所有对象的类变量值都会发生变化。

> 不能把任何方法体内的变量声明为静态方法。

### 静态方法

成员方法前用 static 修饰，则成员方法就为静态方法。

静态方法可以通过 类名 直接访问，也能通过类的实例对象来访问。

静态方法里只能调用同类中的其他静态成员（包括变量和方法），不能直接访问类中的非静态方法。

- *原因：非静态方法和变量需要先创建实例对象后才能使用，但是静态方法不需要创建任何对象，只要类存在就可以调用。普通成员创建时间晚于静态方法，因此静态方法不能直接访问普通成员。*

- main方法就是静态方法，main 方法不能直接访问类中的 非静态成员，需要创建实例对象，通过对象访问 非静态成员。

### 静态成员特点

静态成员是指 静态变量和静态方法，有以下特点：

1. 静态变量在内存中只有一个，当JVM 加载类的时候会为静态变量分配空间，静态变量能所有实例共享。
2. 静态变量可以通过类名直接访问，也能通过类的实例进行访问。
3. 静态变量的生命周期与类的生命周期一只。
4. 静态方法不能直接访问所属类中的非静态成员。

## 聚合类

一个类中包含许多相同类型的数据项称为聚合类

例如：

- 一个飞机有很多乘客
- 一个邮包有很多信件
- 一个邮件有很多文字

## 内部类

在一个类的内部定义类，就是内部类。

内部类可以直接访问 `嵌套它的类（外部类）`的成员，但是内部类的成员却不能被`嵌套它的类 （外部类）` 进行访问。

- 在类中直接定义的内部类的使用范围仅限于这个类的内部。
- A 包含 B，B被 A 所知，但是 B 不能被A 以外所知。

# 6 继承与多态

## 继承

继承是在已有的类上的基础上构建新的类，子类可以继承父类所有的`非私有的成员和变量`。

Java类中只允许使用，单继承，不支持使用多继承，但是可以采用多重继承。

![image-20220929105141958](https://83-cloud-space.oss-cn-shenzhen.aliyuncs.com/File/Typora/202209291051208.png)

一个父类可以被多个子类继承。

在继承的时候，在构造子类之前，必须要先构造其父类。

![image-20220929120703367](https://83-cloud-space.oss-cn-shenzhen.aliyuncs.com/File/Typora/202209291207757.png)

## 方法重载

## super 关键字

用 super 可以调用父类的构造方法。

super 可以调用父类的成员方法（变量）

## 抽象类

在抽象类中，使用`abstract` 来定义抽象类。

```java 
public abstract class class_name{
    ……
    abstract 返回值 method_name([参数]);
}
```

1. 抽象类中可以有具体的方法和抽象的方法。
2. 抽象类中的抽象方法在子类中必须实现，具体方法可以不用重写。
3. 抽象类不能直接实例化，如果一定要实例化抽象类，则必须实现抽象类中的抽象类。
4. 抽象方法：只有方法说明，没有方法实现。抽象类中的抽象方法的abstract 关键字不能省略。

## 接口

在接口中，使用`interface`关键字来定义接口

接口是一系列没有实现的方法和常量的组合，是一个功能模块。

1. 接口中的方法都是抽象方法，接口中只能定义常量。
2. 接口中的抽象方法可以省略 abstact 和 public 关键字
3. 接口的继承使用extends 关键词

接口的实现类：

1. 接口的实现类使用implements 关键字。
2. 一个类可以实现多实现。
3. 实现接口的类必须实现接口中的所有的方法，否则为抽象类。

接口和抽象类的比较：

1. 抽象类和接口都不能实例化对象
2. 一个子类如果没有实现抽象类（接口）中所有的抽象方法，则这个子类是抽象类
3. 接口和抽象类都能实现Java的多态性。
4. 抽象类中可以定义非抽象的方法，但是接口中的所有方法都是抽象方法。

接口和类的比较：

1. 类只能实现单继承，但是接口可以是多继承。

2. 子类必须要实现接口中的所有的方法，子类继承父类方法，子类可以选择的重写父类中的方法。

3. 继承在Java中是父与子的关系，实现在Java中实现者只是具有接口中定义的行为即可。


## final 修饰符

final 修饰类，表示该类不能被继承

final 修饰成员变量，表示该变量不能被重新赋值

final 修饰成员方法，表示该方法不能被重写

### 静态绑定和动态绑定

静态方法和成员变量，使用静态绑定

实例方法使用动态绑定。只有实例方法才能被覆盖。

在Java中存在两种绑定方式，一种为静态绑定，又称作早期绑定。另一种就是动态绑定，亦称为后期绑定

1. 静态绑定发生在编译时期，动态绑定发生在运行时
2. 使用private或static或final修饰的变量或者方法，使用静态绑定。而虚方法（可以被子类重写的方法）则会根据运行时的对象进行动态绑定。
3. 静态绑定使用类信息来完成，而动态绑定则需要使用对象信息来完成。
4. 重载(Overload)的方法使用静态绑定完成，而重写(Override)的方法则使用动态绑定完成。
5. 静待绑定是在编译时就已经确定该使用哪个变量或调用哪个方法；动态绑定是在运行是确认调用哪个方法更合适，是一个选择的过程，因为在多态中子类会重写父类的方法，这样就会出现多个重名的方法，在调用时会根据子类对象确认哪个方法更适合子类对象

```JAVA
public class Fathers {
    String var = "FatherVar";
    static String staticVar = "StaticFatherVar";

    void method() {
        System.out.println("Father method");
    }

    static void staticMethod() {
        System.out.println("Static Father method");
    }
}

class Sons extends Fathers {
    String var = "SonVar";
    static String staticVar = "StaticSonVar";

    void method() {
        System.out.println("Son method");
    }

    static void staticMethod() {
        System.out.println("Static Son method");
    }

    String sonVar = null;

    void sonMethod() {
    }
}
class Tester{
    public void test(){
        Fathers f=new Sons();
        //Fathers f=new Fathers();
        //Sons f=new Sons();
        //Sons f=(Sons)new Fathers();

        System.out.println(f.var);
        System.out.println(f.staticVar);
        f.method();
        f.staticMethod();
    }

    public static void main(String[] args){
        new Tester().test();
    }
}
```



# 包（package）

# 异常处理

## 异常的概念

程序可控制异常：

- 这类异常是可以被系统发现的，并通过程序可以被处理和控制，一般是可预见的错误，不是致命的。

程序不可控制异常

- 

人为异常

- 

异常的基类：Throwable ，该类不能直接使用。

- 异常类基类 throwable 派生出两个子类：

  - Exception
  - Error

  



## 异常处理

### 捕获异常

### 抛出异常

### 自定义异常



# 集合类

## 迭代