java基础九

六义义

722人浏览 · 2026-01-17 09:31:07

六义义 · 2026-01-17 09:31:07 发布

数组

1数组的概念

数组就是用于存储数据的长度固定的容器，保证多个数据的数据类型要一致。

int[] arr = {54,96,55,0,0};
//        String[] str = {"","","",""};
//        arr表示的就是一个数组  是由int类型组成的数组

特点：

1、数组的长度一旦确定就不能修改

2、创建数组时会在内存中开辟一整块连续的空间。

3、存取元素的速度快，因为可以通过[下标]，直接定位到任意一个元素。

2数组的分类

1、按照维度分：

一维数组：存储一组数据
二维数组：存储多组数据，相当于二维表，一行代表一组数据，这是这里的二维表每一行长度不要求一样。

2、按照元素类型分：

基本数据类型的元素：存储数据值
引用数据类型的元素：存储对象（本质上存储对象的首地址）（这个在面向对象部分讲解）

注意：无论数组的元素是基本数据类型还是引用数据类型，数组本身都是引用数据类型。

2一维数组的声明与使用

[]表示一维数组

 char[] arr = {'a','b','c'};

[] [] 表示二维数组

int[][] arr1 = {{7,7,7},{5,5,5},{1,1,1}

2 一维数组的静态初始化

什么是初始化？
- 初始化就是确定数组元素的总个数（即数组的长度）和元素的值
什么是静态初始化？
- 静态初始化就是用静态数据（编译时已知）为数组初始化。此时数组的长度由静态数据的个数决定。

3 一维数组的使用

获取数组长度

数组名.length

表示数组中的一个元素

数组名[索引/下标]

数组的下标范围

Java中数组的下标从[0]开始，下标范围是[0, 数组的长度-1]，即[0, 数组名.length-1]

4 数组下标越界异常

java.lang.ArrayIndexOutOfBoundsException // 索引下标越界

4 一维数组的遍历

数组遍历： 将数组的全部内容通过循环全部使用一遍

public class Final {
    public static void BianLi(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }

    public static int Max(int[] arr) {
        int Max = arr[0];

        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > Max) {
                Max = arr[i];
            }
        }
        return Max;
    }
    public static int Min(int[] arr) {
        int Min = arr[0];

        for (int i = 0; i < arr.length; i++) {
            if (arr[i] <Min) {
                Min = arr[i];
            }
        }
        return Min;
    }
    public static int Jun(int[] arr){
        int he = 0;
        int Jun = 0;
        for (int i = 0; i < arr.length; i++){
            he =he+arr[i];

        }
        Jun = he/arr.length;
        return Jun;
    }

5 数组元素的默认值

当我们使用动态初始化方式创建数组时，元素只是默认值

3Java虚拟机的内存划分

[I@1b6d3586 是数组保存在内存中的地址

2.数组下标为什么是0开始

因为第一个元素距离数组首地址间隔0个单元格。

4 一维数组的常见算法

1 数组统计：求总和、均值、统计偶数个数等

 int[] arr = {4,6,8,7,9,2,1};
//        int he = 0;
////        平均值
//        for(int i = 0;i<arr.length;i++){
////            求和
////            System.out.println(arr[i]);
//            he = he + arr[i];
//
//        }
//        System.out.println(he/ arr.length);


//        int[] arr = {4,6,8,7,9,2,1};
////        找到 奇数和偶数
//        for(int i = 0;i< arr.length;i++){
//            if(arr[i] % 2 == 0){
//                System.out.println("这个数字是偶数  " + arr[i]);
//            }else {
//                System.out.println("这个数字是奇数  " + arr[i]);
//            }
//        }

2 数组找最值

1、找最大值/最小值

1.先假设第一个元素最大/最小

2.然后用max/min与后面的元素一一比较

int[] arr = {4,66,8,7,9,2,1};
          int max = arr[0];
          int max_index = 0;
          int min = arr[0];
          int min_index = 0;

index 索引下标

5冒泡

冒泡相邻两两比较直接交换位置 // 内层循环相邻两两比较交换位置最终确定一个值的最终位置 // 外层循环把内层循环的最终结果执行给每一个数字

  int[] arr = {5,6,1,8,9,7};
 for(int i = 0;i<arr.length;i++){
            for(int j = 0;j<arr.length-i-1;j++){
                if(arr[j] < arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        for(int i = 0;i< arr.length;i++){
            System.out.println(arr[i]);
        }
    }
}

包装类

1包装类

Java提供了两个类型系统，基本类型与引用类型，使用基本类型在于效率，然而当要使用只针对对象设计的API或新特性（例如泛型），那么基本数据类型的数据就需要用包装类来包装。

序号	基本数据类型	包装类（java.lang包）
1	byte	Byte
2	short	Short
3	int	Integer
4	long	Long
5	float	Float
6	double	Double
7	char	Character
8	boolean	Boolean
9	void	Void

包装类装箱把基本数据类型装起来变成包装类

 Integer num1 = new Integer(b);

拆箱把包装类的值，拆分成基本数据类型的值

int a = num1.intValue();

jdk1.5之后自动装箱和拆箱

装箱和拆箱

Integer i = 4;//自动装箱。相当于Integer i = Integer.valueOf(4);

i = i + 5;//等号右边：将i对象转成基本数值(自动拆箱) i.intValue() + 5;

3 包装类的一些API

1、基本数据类型和字符串之间的转换

（1）把基本数据类型转为字符串

int a = 10;
//String str = a;//错误的
//方式一：
String str = a + "";
//方式二：
String str = String.valueOf(a);

2）把字符串转为基本数据类型

String转换成对应的基本类型，除了Character类之外，其他所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型，例如：

public static int parseInt(String s)：将字符串参数转换为对应的int基本类型。
public static long parseLong(String s)：将字符串参数转换为对应的long基本类型。
public static double parseDouble(String s)：将字符串参数转换为对应的double基本类型。

或把字符串转为包装类，然后可以自动拆箱为基本数据类型

public static Integer valueOf(String s)：将字符串参数转换为对应的Integer包装类，然后可以自动拆箱为int基本类型
public static Long valueOf(String s)：将字符串参数转换为对应的Long包装类，然后可以自动拆箱为long基本类型
public static Double valueOf(String s)：将字符串参数转换为对应的Double包装类，然后可以自动拆箱为double基本类型

注意:如果字符串参数的内容无法正确转换为对应的基本类型，则会抛出java.lang.NumberFormatException异常。

2、数据类型的最大最小值

Integer.MAX_VALUE和Integer.MIN_VALUE
Long.MAX_VALUE和Long.MIN_VALUE
Double.MAX_VALUE和Double.MIN_VALUE

3、字符转大小写

Character.toUpperCase('x');
Character.toLowerCase('X');

4、整数转进制

Integer.toBinaryString(int i) 
Integer.toHexString(int i)
Integer.toOctalString(int i)

5、比较的方法

Double.compare(double d1, double d2)
Integer.compare(int x, int y)

4 抽象类

1 由来

抽象：即不具体、或无法具体

例如：当我们声明一个几何图形类：圆、矩形、三角形类等，发现这些类都有共同特征：求面积、求周长、获取图形详细信息。那么这些共同特征应该抽取到一个公共父类中。但是这些方法在父类中又无法给出具体的实现，而是应该交给子类各自具体实现。那么父类在声明这些方法时，就只有方法签名，没有方法体，我们把没有方法体的方法称为抽象方法。Java语法规定，包含抽象方法的类必须是抽象类。

2 语法格式

抽象方法：被abstract修饰没有方法体的方法。
抽象类：被abstract修饰的类

语法格式：

【权限修饰符】 abstract class 类名{
    
}
【权限修饰符】 abstract class 类名 extends 父类{
    
}

【其他修饰符】 abstract 返回值类型 方法名(【形参列表】);

注意：抽象方法没有方法体

抽象方法子类必须重写父类的抽象方法

抽象方法没有方法体不需要大括号

抽象类中可以没有抽象方法但抽象方法外面只能是抽象类

3 注意事项

抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。

理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。
抽象类中，也有构造方法，是供子类创建对象时，初始化父类成员变量使用的。

理解：子类的构造方法中，有默认的super()或手动的super(实参列表)，需要访问父类构造方法。
抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计。
抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类。

理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义。

4 修饰符一起使用问题

	外部类	成员变量	代码块	构造器	方法	局部变量	内部类（后面讲）
public	√	√	×	√	√	×	√
protected	×	√	×	√	√	×	√
缺省	√	√	×	√	√	×	√
private	×	√	×	√	√	×	√
static	×	√	√	×	√	×	√
final	√	√	×	×	√	√	√
abstract	√	×	×	×	√	×	√
native	×	×	×	×	√	×	×

不能和abstract一起使用的修饰符？

（1）abstract和final不能一起修饰方法和类

（2）abstract和static不能一起修饰方法

（3）abstract和native不能一起修饰方法

（4）abstract和private不能一起修饰方法

tatic和final一起使用：

（1）修饰方法：可以，因为都不能被重写

（2）修饰成员变量：可以，表示静态常量

（3）修饰局部变量：不可以，static不能修饰局部变量

（4）修饰代码块：不可以，final不能修改代码块

（5）修饰内部类：可以一起修饰成员内部类，不能一起修饰局部内部类

接口

1.概述

接口就是规范，定义的是一组规则，体现了现实世界中“如果你是/要...则必须能...”的思想。继承是一个"是不是"的is-a关系，而接口实现则是 "能不能"的has-a关系。

例如：你能不能用USB进行连接，或是否具备USB通信功能，就看你是否遵循USB接口规范
例如：Java程序是否能够连接使用某种数据库产品，那么要看该数据库产品有没有实现Java设计的JDBC规范

2定义格式

接口的定义，它与定义类方式相似，但是使用 interface 关键字。它也会被编译成.class文件，但一定要明确它并不是类，而是另外一种引用数据类型。

引用数据类型：数组，类，枚举，接口，注解。

1。接口声明格式

【修饰符】 interface 接口名{
    //接口的成员列表：
    // 公共的静态常量
    //public static final  在接口中会给变量默认添加上
    public static final int x = xxx;
    // 公共的抽象方法
   // public abstract void add();
    void usb_am();
    // 公共的默认方法（JDK1.8以上）
   // public default void bbb(){};
    default void usb_color(){};
    // 公共的静态方法（JDK1.8以上）
   // public static void aaa(){};
    static void usb_xxx(){
        System.out.println("黑色的接口"); };
    // 私有方法（JDK1.9以上）
}

2、接口的成员说明

在JDK8之前，接口中只允许出现：

（1）公共的静态的常量：其中public static final可以省略

（2）公共的抽象的方法：其中public abstract可以省略

理解：接口是从多个相似类中抽象出来的规范，不需要提供具体实现

在JDK1.8时，接口中允许声明默认方法和静态方法：

（3）公共的默认的方法：其中public 可以省略，建议保留，但是default不能省略

（4）公共的静态的方法：其中public 可以省略，建议保留，但是static不能省略

在JDK1.9时，接口又增加了：

（5）私有方法

除此之外，接口中不能有其他成员，没有构造器，没有初始化块，因为接口中没有成员变量需要动态初始化。

7.5.3接口的使用

1.使用接口的静态成员

接口不能直接创建对象，但是可以通过接口名直接调用接口的静态方法和静态常量。

public class TestUsb3 {
    public static void main(String[] args) {
        //通过“接口名.”调用接口的静态方法
        Usb3.xxx();
        //通过“接口名.”直接使用接口的静态常量
        System.out.println(Usb3.MAX_SPEED);
    }
}

2.类实现接口（implements）

接口不能创建对象，但是可以被类实现（implements ，类似于被继承）。

类与接口的关系为实现关系，即类实现接口，该类可以称为接口的实现类，也可以称为接口的子类。实现的动作类似继承，格式相仿，只是关键字不同，实现使用 implements关键字。

implements 实现接口继承可以继承任意的类只能单继承但是实现只能实现接口可以同时实现多个接口

【修饰符】 class 实现类  implements 接口{}
//重写接口中抽象方法【必须】，当然如果实现类是抽象类，那么可以不重写
    // 重写接口中默认方法【可选】

【修饰符】 class 实现类 extends 父类 implements 接口{
    // 重写接口中抽象方法【必须】，当然如果实现类是抽象类，那么可以不重写
    // 重写接口中默认方法【可选】
}

接口中，有多个抽象方法时，实现类必须重写所有抽象方法。如果抽象方法有重名的，只需要重写一次。

注意：

如果接口的实现类是非抽象类，那么必须==重写接口中所有抽象方法==。
默认方法可以选择保留，也可以重写。

重写时，default单词就不要再写了，它只用于在接口中表示默认方法，到类中就没有默认方法的概念了

5、接口的多继承（extends)

一个接口能继承另一个或者多个接口，接口的继承也使用 extends 关键字，子接口继承父接口的方法（可以继承多接口）

public interface UsbC extends Chargeable,Usb3 {
    void reverse();
}

子接口重写默认方法时，default关键字可以保留。

子类重写默认方法时，default关键字不可以保留。

接口的特点总结

接口本身不能创建对象，只能创建接口的实现类对象，接口类型的变量可以与实现类对象构成多态引用。
声明接口用interface，接口的成员声明有限制：（1）公共的静态常量（2）公共的抽象方法（3）公共的默认方法（4）公共的静态方法（5）私有方法（JDK1.9以上）
类可以实现接口，关键字是implements，而且支持多实现。如果实现类不是抽象类，就必须实现接口中所有的抽象方法。如果实现类既要继承父类又要实现父接口，那么继承（extends）在前，实现（implements）在后。
接口可以继承接口，关键字是extends，而且支持多继承。
接口的默认方法可以选择重写或不重写。如果有冲突问题，另行处理。子类重写父接口的默认方法，要去掉default，子接口重写父接口的默认方法，不要去掉default。
接口的静态方法不能被继承，也不能被重写。接口的静态方法只能通过“接口名.静态方法名”进行调用。