✦亿轨星途
← 返回首页
Java学习

3.再识Java

2026-09-19·1 次浏览
3.再识Java

Java核心基础

1.1数组

是一种可以存放大量类型相同的变量的数据结构，是一个具有相同数据类型的数据集合。数组中的数据类型必须是相同的。

1.1.1数组的基本要素

数组名称

数组元素

元素下标

数据类型

数组中的每个数据都有一个下表，从0开始，相当于编号，通过编号可以快速检索到对应的数组，数组里的所有元素必须是同一种类型

1.1.2如何使用数组

声明数组

分配内存空间

给数组赋值

使用数组

数组在创建的时候必须指定其长度

同样的，具体的数据是存储在堆内存里的，栈内存里只保留对应数据的首地址的引用，其余下标的则是根据头地址计算出来的

1.1.3 数组的常见错误

数组声明时数据类型不匹配

数组中能否同时存入int和String类型的数据，这看似和前面的同一数据类型矛盾了，但是其实并没有违反，这就是Object类型的数组，因为Object是所有类的父类

java Copy 
Object[] object = new Object[3];
        object[0] = 1;
        object[1] = "hello";
        object[2] = true;

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

边声明边赋值必须写在一行

数组下标越界

1.1.4数组常用的操作和方法

求数组中的最大值

java Copy 
 int[] arr = {12,35,1,4,65,87,15,65};
        int max = arr[0];
        for(int i: arr){
            if(i>max){
                max=i;
            }
        }
        System.out.println(max);

求数组中的最小值

Java Copy 
 int[] arr = {12,35,1,4,65,87,15,65};
        int min = arr[0];
        for(int i: arr){
            if(i《min){
                min=i;
            }
        }
        System.out.println(min);

在数组中插入一个数

java Copy 
        int[] arr = {12, 35, 1, 4, 65, 87, 15, 65};
        int[] arr1 = new int[arr.length + 1];

        for (int i = 0; i < arr1.length; i++) {
            if (i < 3) {
                arr1[i] = arr[i];
            } else if (i == 3) {
                arr1[i] = 56;
            } else {
                arr1[i] = arr[i - 1];
            }
        }

        for (int i : arr) {
            System.out.print(i+" ");

        }
        System.out.println();
        for (int n : arr1) {
            System.out.print(n+" ");
        }

数组排序，十分典型的冒泡排序

java Copy 
int[] arr = {12, 35, 1, 4, 65, 87, 15, 64};

        for (int i = 0; i < arr.length -1; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[i] > arr[j]) {
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        for (int i : arr) {
            System.out.print(i+" ");
        }

Arrays.toString()的使用

Arrays是JDK提供的一个针对于数组的工具类，专门用来操作数组，存储在java.util包里面

Copy 
 int[] arr = {12, 35, 4, 1, 65, 87, 15, 64};
        int[] arr2 = {12, 35, 4, 1, 65, 87, 15, 64};
        System.out.println(Arrays.equals(arr, arr2));
        Arrays.sort(arr);
        Arrays.fill(arr2,10086);
        System.out.println(Arrays.toString(arr));
        System.out.println(Arrays.toString(arr2));
        int[] arr3 = Arrays.copyOf(arr, arr.length);
        System.out.println(Arrays.toString(arr3));

1.2二维数组

二维数组主要体现数据一种二维结构，方便理解和代码开发复用，简单来说就是一个一维数组的元素是一个一维数组，前者一维数组保存后者一维数组的地址引用

声明

开辟内存空间

赋值

面向对象

面向对象是一种编程思维,Java就是面向对象的编程语言

也就是万物皆对象，我们可以把Java程序看成是很多个对象构建的系统，具体来说就是将Java程序的所有参与角色都看成一个个对象，通过对象之间的相互调用来完成系统的功能

2.1什么是面向对象

面向过程，结构化的编程方式

面向过程注重的是每一个步骤，面向对象关注点在于整件事情的模块化结构

面向对象核心思想是重用性和灵活性（灵活性=可扩展性+变化性）

重用性是指已经写好的某个程序，可以在其他业务场景中使用

2.2类和对象

1.属性：对象的静态特征

2.方法：对象的动态特征

对象就是用来描述客观存在的一个实体，该实体由一组属性和方法构成

类就是产生对象的模板，所有的对象都是通过类创建的

对象和类的关系：类是对象的抽象化描述，对象是类的具体实例

2.3 构造函数

类是用来创建对象的，如何创建？通过构造函数来创建

构造函数就是类中的一个方法，只能用来创建对象

构造函数、构造方法、构造器

每个类都有一个默认的构造函数（没有参数的）

当类中声明了一个有参构造函数之后，就会覆盖默认的无参构造

2.4创建对象

创建对象只需要调用对应的类的构造函数即可，构造函数又分为有参构造和无参构造

通过无参构造创建对象之后，需要手动给属性赋值

通过有参构造创建对象之后，可以在创建的时候给属性赋值

对修改关闭，对扩展开放

2.5使用对象

使用对象包裹获取和修改属性，以及调用方法，访问属性通过 对象名.属性名 来完成，调用方法通过 对象名.方法名（参数列表）来完成

2.6 this关键字

this指当前对象，但是每一次的this的对象不一样

2.7 方法重载

方法重载是Java代码复用的一种重要方式，指的是两个方法之间的关系

1.在同一个类里面

2.方法名相同

3.参数列表不同

4.与方法返回值和访问权限修饰符无关

2.8 成员变量和局部变量

变量的作用域：在程序中可以通过变量名来访问改变量的范围

变量的作用域由变量被声明时所在的位置来决定

成员变量和局部变量

如果一个变量被声明在方法中，则该变量是局部变量

如果一个变量被声明在方法外，则该变量是成员变量

成员变量的作用域在整个类中，类中的每一个方法都可以访问这个变量，局部变量的作用域只在定义该变量的方法中，除了方法就无法访问

2.9 封装

面向对象的三大特征：封装、继承、多态

封装就是将类的属性隐藏在内部，外部不能直接访问和修改，必须通过类提供的方法来完成对属性的访问和修改

封装的核心思想就是尽可能把属性都隐藏在内部，对外部提供方法来访问，我们可以在这些方法汇中添加逻辑处理来实现过滤，以此来屏蔽错误的数据赋值

2.9.1封装的步骤

  1. 修改实现的访问权限，使得外部不能直接访问
  2. 提供外部可以直接访问的方法
  3. 在该方法中加入属性的逻辑控制

2.10 static关键字

static标识静态或全局，可以用来修饰程艳变量和成员方法以及代码块。

成员变量和成员方法的访问必须依赖于对象

使用static修饰的成员变量和成员方法独立于该类的任何一个实例对象，访问时不需要依赖于对象，可以直接通过类来访问

可以理解为被该类的所有实例对象共用

static修饰的成员变量 叫做类变量或者静态变量

static修饰的成员方法叫做类方法或者静态方法都可以直接通过类来访问

static修饰的静态变量在内存中只有一份，多个对象共享

没有用static修饰的成员变量在内存中有多分，每个对象独享自己的成员变量

static除了可以修饰成员变量和成员方法之外，还可以修饰代码块，被static修饰的代块叫做静态代码块

静态代码块的特点是只执行一次

当该类被加载到内存中的时候执行，自动执行，不需要手动调用

程序运行时，首先会将需要用到的类加载到内存中，并且只加载一次

然后通过这个类来创建多个对象完成具体的业务逻辑

如果有多个静态代码块，则按先后顺序执行，类的构造方法用于初始化类的实例，类的静态代码块用于初始化类，给类的变量赋值

2.11 继承

代码复用的重要方式，可以减少重复代码的数量，提高开发效率

2.11.1 子类访问父类

创建子类的时候，会默认优先创建父类对象，无论调用的是子类的无参还是有参构造，创建父类的时候都是调用无参构造

那么怎么让父类调用有参来创建对象呢，在子类里面使用super(),这里是个超类，调用父类的构造器，例如父类里面的有参是传入一个int类型的id，那就super(1)，传一个id为1进去，就能调用父类的有参

2.11.3 子类访问权限

访问权限修饰符可以用来修饰类、属性和方法、不同的的访问权限修饰符表示不同的作用域，包括public、protected、默认修饰符、private

修饰符 同一个类 同一个包 不同包 子类
public 可以访问 可以访问 可以访问 可以访问
protected 可以访问 可以访问 不可以访问 可以访问
默认修饰符 可以访问 可以访问 不可以访问 不可以访问
private 可以访问 不可以访问 不可以访问 不可以访问
  1. 创建子类对象时会默认调用父类的无参构造
  2. 子类调用父类的公有方法

2.11.4 方法重写

这里在继承父类方法的基础上，对父类方法重新定义并覆盖的操作叫做方法重写

通过重写的方式可以实现子类完成特定需求的功能

方法重写的规则

1.父子类的方法名相同

2.父子类的方法参数列表相同

3.子类方法返回值和父类方法返回值类型相同或者是其子类

4.子类方法的访问权限不能小于父类

重写的前提是继承，然而private修饰的方法是不能被继承的

2.11.5 方法重写和方法重载

类型 所在位置 方法名 参数列表 返回值 访问权限
方法重写 子类 相同 相同 相同或者是其子类 不能小于父类
方法重载 同一个类 相同 不相同 没有要求 没有要求

2.12 多态

多态概念本身比较抽象

定义一个方法，在具体的生产环境中根据不同的需求呈现出不同的业务逻辑

java Copy 
public class People {
    public void role(){}
}
java Copy 
public class Student extends People {
    @Override
    public void role() {
        System.out.println("我是学生");
    }
}
java Copy 
public class Teacher extends People {
    @Override
    public void role() {
        System.out.println("我是老师");
    }
}
java Copy 
public static void main(String[] args) {
        Student s1 = new Student();
        Teacher t1 = new Teacher();

        s1.role();
        t1.role();
    }

2.12.1 多态的使用

在实际开发汇总，多态主要有两种表现形式：一种是定义方法时形参为父类，调用方法时传入的参数为子类对；另外一种是定义方法时返回值的数据类型为父类，调用方法时返回子类对象

1.定义方法时形参为父类

java Copy 
public void who(People people){
        people.role();
    }



    public static void main(String[] args) {
        Student s1 = new Student();
        Teacher t1 = new Teacher();

        test t = new test();

        t.who(s1);
        t.who(t1);
    }

2.定义方法时返回值的数据类型为父类，调用方法时返回子类对象

java Copy 
public class test {
    public People who(String name){
        if (name.equals("student")){
            return new Student();
        }else{
            return new Teacher();
        }
    }



    public static void main(String[] args) {
        Student s1 = new Student();
        Teacher t1 = new Teacher();

        test t = new test();

        System.out.println(t.who("student"));
        System.out.println(t.who("teacher"));
    }
}

2.12.2 抽象方法和抽象类

父类

java Copy 
public class Member {
    public void buybook(){

    }
}

子类

java Copy 
public class OrdinaryMember extends Member{
    @Override
    public void buybook() {
        System.out.println("普通会员打九折");
    }
}
java Copy 
public class SuperMember extends Member{
    @Override
    public void buybook() {
        System.out.println("超级会员打八折");
    }
}

buybook方法只需要声明，不需要具体的实现，没有方法体的方法叫做抽象方法，抽象方法需要添加abstract关键字。

一旦一个类里面出现了一个抽象方法，则该类必须声明为抽象类

java Copy 
public abstract class Member {
    public abstract void buybook();
}

抽象类和普通类的区别是抽象类不能实例化，抽象方法和普通方法的区别是抽象方法没有方法题。抽象类中可以没有抽象方法，但是包含了抽象方法的类必须被定义为抽象类

可以在抽象类中定义普通方法，但是普通类里面不能有抽象方法

── 完 ──

评论

还没有评论，来说点什么
发表评论
0 / 1000