java学习记录

基本概念

成员变量：类内部的变量

标识符：任意字母，下划线，美元符号，数字，数字不能开头；

this 关键字：表示本类当前使用的对象，当前前对象不是某个new出来的实体对象，而是当前正在编辑的对象。（只能在本类中使用）作用：将形参传递给实参。

static关键字，由其修饰的变量叫静态变量，方法叫静态方法。使用static关键字可以共享内存区域不用反复定义。调用：类名.静态成员

静态成员依然遵守修饰符的约束

在静态方法中不可以使用this关键字。
在静态方法中不可以直接调用非静态方法。
局部变量不可以使用static关键字声明。
主方法必须用static声明。
只有内部类可以使用static关键字声明。

成员：类的所有东西，包括成员变量和方法；

方法的定义：

方法包括一个方法的开头和一个方法体。
修饰符返回值类型方法名（参数类型参数名）{
方法体；
返回值；}
这个参数可以是对象，也可以是基本数据类型

get与set方法

public String getName() {
   return name;}

    public void setName(String name) {
    this.name = name;}

类和对象

‌ 类是一种抽象的数据类型，他是对某一类事物的整体描述/定义。
使用new 创建对象
通常情况下一个类能不能直接使用，需要根据一个类创建一个对象，才能使用

new关键字

new的本质就是在调用构造方法
初始化对象的值
访问对象的属性和行为：格式：对象.成员
对象的引用：格式：类名称对象名=new 类名称（）;

标准类

（包括如下四个部分）

所有的成员变量都用private修饰
每个成员变量都有get() 和set()方法
一个全参构造有一个无参构造

构造器

类中的构造器也叫构造方法，在进行创建对象的时候必须进行调用。并且每一个类中都隐藏一个无参构造。
格式：

1 2	public 类名称（形参实参） {方法体}

构造器格式：
1.和类名必须相同
2.没有返回值作用

修饰符的级别;public>protected>default（或者是不写）>private

继承

Java中的类只有单继承的关系，没有双继承的关系（相当于一个父类可以有多个子类，但是多个子类只能以有一个父类）。

‌supper代表队的是在子类中调用父类中的属性或者是方法。

继承别人的类，添加自己的功能；
子类拥有并拓展父类；
关键词 extends；

 class 父类{
 父类属性；
 父类方法；}

Class 子类 extends 父类{
子类拓展属性；
子类拓展方法（可以重写父类方法）
     }

调用：

1	子类对象 = new 子类();

super关键字

由于子类不能继承父类的构造方法 ，因此，如果要调用父类的构造方法，可以使用 super 关键字。 super 可以用来访问父类的构造方法、普通方法和属性。

super可以用来引用直接父类的实例变量：当子类的成员变量或方法与父类同名时，可以使用 super 关键字来访问。如果子类重写了父类的某一个方法，即子类和父类有相同的方法定义，但是有不同的方法体 super.member
- super可以用来调用直接父类方法: 当父类和子类都具有相同的方法名时，可以使用 super 关键字访问父类的方法super.父类方法;
super()可以用于调用直接父类构造方法基本格式如下： super(parameter-list);
super( ) 必须是在子类构造方法的方法体的第一行。
第一条语句默认为调用父类的无参构造方法所以当在父类中定义了有参构造方法，但是没有定义无参构造方法时，编译器会强制要求我们定义一个相同参数类型的构造方法。

object类

所有类都继承于java.lang.Object
在object中包含toString(),equals()方法
toString（）方法是将一个对象放回为字符串形式，（在运用中常常重写该方法，为对象提供一个特殊的输出模式）
格式：

1
2
3

public string ToString（）{
return 内容
}

equals方法

equals 比较的是两个对象的实际值
而== 比较的是对象的内存地址

对象类型转化

上转型：从具体的类到抽象的类转化；
父类对像 = new 子类（）；（从具体到抽象）
但父类不可以调用子类的属性和方法；
下转型：将父类对象转化为子类对象（从抽象到具体）
不安全所以需要强制类型转化
子类子类对象 = （子类类型）父类对象；

方法的重载：

定义：在一个类中允许方法名相同，而形参个数，类型不同；

编译器利用 方法名，参数的、类型、个数、顺序来确定方法是否唯一

final关键字：

final变量

使用final关键字可以保证值不被改变；

使用时声明时同时赋值（final double PI = 3.141）

final方法

使用final可以防止子类修改父类的方法；

使用private修饰方法时就隐式的将方法定义为final方法所以无需定义private为final

final类

无法被_继承_和_修改_

该类的所有方法都是隐式final方法

但是成员变量可以定义为final 或非final

多态

是利用方法的重载，减少代码冗余。

抽象与接口

抽象类

关键字：abstract

一般将父类定义为抽象类，无法完成实例化，只能被继承才能使用；

abstract 定义的方法叫抽象方法，抽象方法只能在重写才能使用；

抽象类被继承后需要实现其中所有的抽象方法，也就是保证以相同的方法名称、参数列表值类型创建出非抽象方法，当然也可以
是抽象方法。_但这造成了代码冗余_所以引入接口

接口

接口是抽象的延伸

接口的所有方法都是空方法；

public interface 接口名{

void 方法（）；

}

接口的调用关键词：implements

1	class implements 接口1，接口2，接口3

这会产生大量代码，利用接口的继承可以继承另一个接口的所有方法；

异常处理

异常捕捉

try{
\\可能异常的代码
}
catch(Excepectiontype e1){\* 激发捕获的异常  *\
\\处理1
}
catch(Excepectoin  e){
   e.printStackTrace();\输出异常性质\
}

finally{\* 完整的语句一定有finally且一定被执行但以下的除外：
    在finally 语句块中发生了异常。
    在前面的代码中使用了System.exit()退出程序。
    程序所在的线程死亡。
    关闭 CPU。*\

}

自定义异常

使用Java内置的异常类可以描述在编程时出现的大部分异常

Exception类即可自定义异常类。在程序中使用自定义异常类，

（1）创建自定义异常类。
（2）在方法中通过throw关键字抛出异常对象。
(3)如果在当前抛出异常的方法中处理异常，可以使用try-catch语句进行捕获并处理；

public class Myexception  extends Exception{
 public Myexception(String Error){
   super(Error);  }
}

在方法中抛出异常

数组

当你需要保存一组相同类型的数据时，使用数组是非常有用的。在Java中，数组是一种对象类型，可以用来存储基本类型数据，如整数和字符，或引用类型数据，如字符串或自定义类型。

创建数组：可以使用new关键字创建数组对象。例如，下面的代码创建了一个包含5个整数的数组：（静态定义）

1	int[] arr = new int[5];

  2. 访问数组元素：可以使用下标来访问数组元素。注意，数组的下标从0开始。例如，下面的代码将访问数组中的第三个元素（即下标为2的元素）：（动态定义）

1 2	int[] arr = {1, 2, 3, 4, 5}; int thirdElement = arr[2];

3.数组长度：可以使用length属性获取数组的长度。例如，下面的代码将输出数组arr的长度：

1 2	int[] arr = {1, 2, 3, 4, 5}; System.out.println(arr.length); // 输出 5

4.多维数组：Java支持多维数组，例如二维数组。可以通过在创建数组时指定每个维度的大小来创建多维数组。例如，下面的代码创建了一个_3x3_的二维数组：

1	int[][] arr = new int[3][3];

数组的基本操作

遍历数组：可以使用循环语句来遍历数组中的所有元素。例如：

1	for (int i = 0; i < myArray.length; i++) { System.out.println(myArray[i]); }

这将依次输出数组myArray中的所有元素。
Java中有很多方法可以用来复制，填充，替换，排序和查询数组。
使用System.arraycopy()方法来复制数组，
使用Arrays.fill()方法来填充数组，
使用Arrays.sort()方法来排序数组，
使用Arrays.binarySearch()方法来查询数组。

import java.util.Arrays;

public class ArrayExample {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};
        int[] copy = new int[5];

        // 复制数组
        System.arraycopy(numbers, 0, copy, 0, numbers.length);
        System.out.println("复制后的数组: " + Arrays.toString(copy));

        // 填充数组
        Arrays.fill(copy, 0);
        System.out.println("填充后的数组: " + Arrays.toString(copy));

        // 替换数组中的元素
        copy[2] = 9;
        System.out.println("替换后的数组: " + Arrays.toString(copy));

        // 排序数组
        Arrays.sort(numbers);
        System.out.println("排序后的数组: " + Arrays.toString(numbers));

        // 查询数组
        int index = Arrays.binarySearch(numbers, 3);
        System.out.println("数字3在数组中的索引: " + index);
    }
}