Java se

一.类和对象

工具类

image

final关键字

final修饰的特点是只能被赋值一次，一旦赋值，无法再次修改
基本数据类型：byte，short，int，long，float，double，char，boolean
变量里面记录的是真实的数据
final int a=10；此时变量里面记录的数据无法发生改变
引用数据类型：除了上面的类型，其他都是引用类型，比如int[]数组，Student,Teacher类
final Student stu=new Student(); //stu变量存在栈区，而stu指向的真正数据存在堆区
stu里面记录的是对象的内存地址，不可改变的是stu记录的内存地址，而对象里面的属性，是可以发生改变
image

static关键字

image

enum枚举类

image
image
应该是每个枚举类的枚举项都要调用构造函数√，每个枚举类对象都要创建×
image
values()是获取本类的所有枚举项，一个默认的类方法
image

继承

extends关键字
image
image
super.可以访问与子类同名的父类中的成员变量

继承中的构造方法

image

作业

image

package com.itheima.oopextendstest2;

public class Test {
    public static void main(String[] args) {
        manager m = new manager("1","张三",5000,500);
        System.out.println(m.getId()+m.getName()+m.getSalary()+m.getBonus());
        m.work();
        m.eat();
        System.out.println("==================");
        cook p = new cook("100","李四",3000);
        System.out.println(p.getId()+p.getName()+p.getSalary());
        p.work();
        p.eat();
    }
}

package com.itheima.oopextendstest2;

public class person {
    private String id;
    private String name;
    private double salary;

    public person(){
    }
    public person(String id,String name,double salary){
        this.id = id;
        this.name = name;
        this.salary = salary;
    }

    public void setId(String id){
        this.id = id;
    }
    public String getId(){
        return id;
    }

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

    public void setSalary(double salary){
        this.salary = salary;
    }
    public double getSalary(){
        return salary;
    }
    public void work(){
        System.out.println("员工" + name + "正在工作");
    }
    public void eat(){
        System.out.println("员工" + name + "正在吃");
    }
}

package com.itheima.oopextendstest2;

public class manager extends person {
    private double bonus;

    public manager(){
    }
    public manager(String id,String name,double salary,double bonus){
        super(id,name,salary);
        this.bonus = bonus;
    }

    public void setBonus(double bonus){
        this.bonus = bonus;
    }

    public double getBonus(){
        return bonus;
    }
    @Override
    public void work(){
        System.out.println("经理" + super.getName() + "正在管理其他人");
    }
    @Override
    public void eat(){
        System.out.println("经理" + super.getName() + "正在吃米饭");
    }
}


package com.itheima.oopextendstest2;

public class cook extends person {
    public cook(){}
    public cook(String id,String name,double salary){
        super(id,name,salary);
    }

    @Override
    public void work(){
        System.out.println("厨师" + super.getName() + "正在炒菜");
    }
    @Override
    public void eat(){
        System.out.println("厨师" + super.getName() + "正在吃米饭");
    }
}

子类从父类继承的内容

image
补充下ai找的内容：
image
image
虚方法的继承实际上是用了一个虚方法表来记录能调用方法的地址，这样就不用一级一级往上从父类找地址，从而实现了空间换时间的思想
image

权限修饰符

image

多态

image
补充：方法调用时如果子类中方法重写会调用重写的方法，如果未重写，实际调用的还是父类的方法

多态练习

image

package com.itheima.oopextendstest3;

public class Test {
    public static void main(String[] args) {
        Person p = new Person("张三",18,"男");
        System.out.println(p.getName() + p.getAge() + p.getGender());
        p.drive(new Bicycle("凤凰",20));
        p.drive(new Car("保时捷",300));
    }
}

package com.itheima.oopextendstest3;

public class Vehicle {
    private String brand;
    private double speed;

    public Vehicle(){
    }
    public Vehicle(String brand,double speed){
        this.brand = brand;
        this.speed = speed;
    }
    public void setBrand(String brand){
        this.brand = brand;
    }
    public String getBrand(){
        return brand;
    }
    public void setSpeed(double speed){
        this.speed = speed;
    }
    public double getSpeed(){
        return speed;
    }
    public void move(){
        System.out.println(brand + "正在以" + speed + "km/h的时速行驶");
    }
}


package com.itheima.oopextendstest3;

public class Bicycle extends Vehicle {
    public Bicycle(){
    }
    public Bicycle(String brand,double speed){
        super(brand,speed);
    }
    @Override
    public void move(){
        System.out.println("自行车" + getBrand() + "正在以" + getSpeed() + "km/h的速度移动");
    }
    public void ringBell(){
        System.out.println("铃~~铃~~铃~~");
    }
}


package com.itheima.oopextendstest3;

public class Car extends  Vehicle{
    public Car(){
        super();
    }
    public Car(String brand,double speed){
        super(brand,speed);
    }
    @Override
    public void move(){
        System.out.println("汽车" + getBrand() + "正在以" + getSpeed() + "km/h的速度行驶");
    }
    public void honk(){
        System.out.println("叭~~叭~~叭~~");
    }
}


package com.itheima.oopextendstest3;

public class Person {
    private String name;
    private int age;
    private String gender;
    public Person(){
    }
    public Person(String name,int age,String gender){
        this.name = name;
        this.age = age;
        this.gender = gender;
    }
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age = age;
    }
    public int getAge(){
        return age;
    }
    public void setGender(String gender){
        this.gender = gender;
    }
    public String getGender(){
        return gender;
    }
    //驾驶
    public void drive(Vehicle vehicle){
        //这里子类bicycle和car重写了move方法，所以可以调用子类的move
        vehicle.move();
        //这里的响铃是子类独有的，需要进行类型转换才可以调用
        if(vehicle instanceof Bicycle){
            Bicycle b = (Bicycle) vehicle;
            b.ringBell();
        }
        if(vehicle instanceof Car){
            Car c = (Car) vehicle;
            c.honk();
        }
    }
}

补充：使用instanceof判断是不是该类

抽象类和抽象方法

image
image
image
image

接口

image
image
image
image

练习

image
image

package com.itheima.oopextendstest4;

//这里person写成抽象类是为了禁止创建对象
public abstract class Person {
    private String name;
    private int age;

    public Person(){
    }
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age = age;
    }
    public int getAge(){
        return age;
    }
}


package com.itheima.oopextendstest4;

public abstract class Sporter extends Person{
    public Sporter(){}
    public Sporter(String name,int age){
        super(name,age);
    }

    public abstract void study() ;

}


package com.itheima.oopextendstest4;

public abstract class Coach extends Person{
    public Coach(){
    }
    public Coach(String name,int age){
        super(name,age);
    }
    public abstract void teach();
}


package com.itheima.oopextendstest4;

//接口文件
public interface English {
    public abstract void speakEnglish();
}

package com.itheima.oopextendstest4;

public class PingPangSporter extends Sporter implements English{
    public PingPangSporter(){
    }
    public PingPangSporter(String name,int age){
        super(name,age);
    }
    @Override
    public void study() {
        System.out.println("乒乓球运动员"+getName()+"在学习打乒乓球");
    }

    @Override
    public void speakEnglish(){
        System.out.println("乒乓球运动员"+getName()+"在说英语");
    }

}


package com.itheima.oopextendstest4;

public class BasketballSporter extends Sporter{
    public BasketballSporter(){
    }
    public BasketballSporter(String name,int age){
        super(name,age);
    }

    @Override
    public void study() {
        System.out.println("篮球运动员在学习打篮球");
    }
}


package com.itheima.oopextendstest4;

public class PingPangCoach extends Coach implements English{
    public PingPangCoach(){
    }
    public PingPangCoach(String name,int age){
        super(name,age);
    }
    @Override
    public void teach() {
        System.out.println("乒乓球教练正在教乒乓球");
    }
    @Override
    public void speakEnglish(){
        System.out.println("乒乓球教练在说英语");
    }
}


package com.itheima.oopextendstest4;

public class BasketballCoach extends Coach{
    public BasketballCoach(){
    }
    public BasketballCoach(String name,int age){
        super(name,age);
    }
    @Override
    public void teach() {
        System.out.println("篮球教练正在教篮球");
    }
}


package com.itheima.oopextendstest4;

public class Test {
    public static void main(String[] args) {
        PingPangSporter p = new PingPangSporter("樊振东",28);
        System.out.println(p.getName() + p.getAge());
        p.study();
        p.speakEnglish();
    }
}

JDK接口的新特性

image
image
image
当一个类使用implements关键字来实现一个接口时，这个类就被称为该接口的“实现类”，即干儿子类（自己瞎起的名字）

image
image

内部类

成员内部类

image

静态内部类

image

局部内部类

image

匿名内部类

image

API

字符串

补充：引用数据类型与普通数据类型区别：引用数据类型存储的是“对象的地址”（即指针），而不是“对象本身”的数据。如果是引用数据类型，那么在栈中存放的是引用地址，在堆中存放的才是数据。
字符串直接赋值
image
new出来的内存结构
image
image

字符串的比较

image
下面两个方法比较的是字符串内容，非地址
image
image

字符串的截取

substring
image
replace
image

image

StringBuilder

image
image

练习：将字符串内容随机排序输出

public class test1 {
    public static void main(String[] args) {
        String str="abcdefghijklmnopqrstuvwxyz";
        //将字符串变成数组
        char[] arr=str.toCharArray();
        //打乱数组arr内容
        Random r=new Random();
        for(int i=0;i<arr.length;i++){
            //获取一个随机索引
            int index=r.nextInt(arr.length);
            char temp=arr[i];
            arr[i]=arr[index];
            arr[index]=temp;
        }
        //把打乱后的字符数组转回字符串
        String result=new String(arr);
        System.out.println(result);

    }
}

练习：定义两个字符串，记录为非负整数，求它们的和，注：可能会有溢出

public class test2 {
    //定义两个字符串，记录为非负整数，求它们的和，注：可能会有溢出
    public static void main(String[] args) {
        //1.定义两个字符串，记录为非负整数
        String str1="1234577566";
        String str2="45862999999999999999";
        //2.把两个字符串的数据放入到int类型的数组里面
        int len=str1.length()>=str2.length()?str1.length():str2.length();

        int[] arr1=copyData(str1,len);
        int[] arr2=copyData(str2,len);

        //3.定义一个数组存入最终的结构，数组的长度+1
        int[] sum=new int[len+1];

        //4.定义一个变量表示进位
        int num=0;

        //5.遍历数组，从个位开始计算
        for(int i=len-1;i>=0;i--){
            int temp=arr1[i]+arr2[i]+num;
            sum[i+1]=temp%10;
            num=temp/10;
        }

        //6.考虑到最终结果的首位有可能为0，所以要判断
        sum[0]=num;

        //7.把sum数组当中的数据拼接成一个字符串
        StringBuilder sb=new StringBuilder();
        if(sum[0]!=0){
            sb.append(sum[0]);
        }
        for (int i = 1; i < sum.length; i++) {
            sb.append(sum[i]);
        }
        System.out.println(sb.toString());
    }
    public static int[] copyData(String str,int len){
        int[] arr=new int[len];
        int index=len-1;
        for(int i=str.length()-1;i>=0;i--){
            arr[index]=str.charAt(i)-48;
            index--;
        }
        return arr;
    }
}

ArrayList集合

image
image

练习

image

package ArrayList;

public class Student {
    //id，姓名，年龄
    private String id;
    private String name;
    private int age;

    public Student(){}

    public Student(String id,String name,int age){
        this.id=id;
        this.name=name;
        this.age=age;
    }
    public String getId(){
        return id;
    }
    public void setId(String id){
        this.id=id;
    }
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name=name;
    }
    public int getAge(){
        return age;
    }
    public void setAge(int age){
        this.age=age;
    }
}


package ArrayList;

import java.util.ArrayList;

public class test {
    public static void main(String[] args) {
        //1.创建集合类型
        ArrayList<Student> list=new ArrayList<Student>();

        //2.创建一些学生对象
        Student s1=new Student("001","张三",18);
        Student s2=new Student("002","李四",19);
        Student s3=new Student("003","王五",20);

        //3.添加到集合
        list.add(s1);
        list.add(s2);
        list.add(s3);

        //4.遍历集合
        for(int i=0;i<list.size();i++){
            Student s=list.get(i);
            System.out.println(s.getId()+" "+s.getName()+" "+s.getAge());
        }

        //5.查找对应的id
        int index=findStudentById(list,"005");
        System.out.println(index);
    }

    //定义一个方法，根据id查找学生的信息
    public static int findStudentById(ArrayList<Student> list,String id){
        for(int i=0;i<list.size();i++){
            Student s=list.get(i);
            if(s.getId().equals(id)){
                return i;
            }
        }
        return -1;
    }

}

包装类

image
好处在于传参的时候，如果形参是对象object，就可以传递，如果你实参用基本类型就无法传递，只能传包装类
image
image
image
image
自动装箱和自动拆箱
image

BigInteger和BigDecimal

BigInteger

image
image
image

BigDecimal

image
image

posted @ 2026-08-25 21:33  zhiyu7  阅读(4)  评论(0)    收藏  举报