面向对象
java 后端
面向对象
java 后端

面向对象

对象内存分配

方法区：储存调用的main函数

栈内存：储存临时变量

堆内存：通过new出来的对象的地址储存在这里

通过方法区的调用，堆内存会将成员方法的地址赋值给栈内存中的临时变量，程序结束时栈内存空间释放，堆内存的数据成为垃圾数据

多态

弊端：不能调用子类的特有功能

解决方法：使用类型转换，将父类转化为子类

包

管理不同功能的java类，方便后期的代码维护

调用其他类时，需要使用全类名

使用不同包中的相同类，需要写全类名

final

方法：最终方法，不能被重写

类：表明该类是最终类，不能被继承

变量：叫做常量，只能被赋值一次

修饰基本类型，值不能改变

修饰引用数据类型，地址值不能改变

package com.wsj.finall;

public class test {
    public static void main(String[] args) {
        Zi z=new Zi();
        z.print();
    }
}


class Fu{
    final int age=10;
    public final void show(){

        System.out.println("父类的show 方法");
    }
}

class Zi extends Fu{
    public void print(){
        System.out.println(age);
    }
}

代码块

局部代码块

写在方法中的代码

思想：用完立马回收，不会浪费空间

构造代码块

写在成员位置的代码块，可以把多个构造方法中重复的代码抽取出来

创建本类对象时，先执行构造代码再执行构造函数

static 静态代码块

需要通过static关键字修饰，随着类的加载而加载，并且自动触发，只执行一次

抽象类和抽象方法

abstract

注意事项：

抽象类不能实例化

抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类

可以有构造方法

抽象类的子类

  • 要么重写抽象类中的所有抽象方法
  • 要么是抽象类

抽象类中的构造方法是创建子类对象时候给属性进行赋值

接口

接口用关键词interface定义

public interface 接口名{}

接口不能实例化

接口和类之间是实现关系，通过interface关键字来表示

public class 类名 implements 接口名{}

接口的子类（实现类）

  • 要么重写接口中所有的抽象方法
  • 要么是抽象类

注意：接口和类的实现关系，可以单实现，也可以多实现

public class 类名 implements 接口1 接口2{}

实现类还可以在继承一个类的同时实现多个接口

public class类名 extends 父名 implements 接口1 接口2{}

成员特点

成员变量

只能是常量

默认修饰符：public static final

构造方法

没有设计构造方法

成员方法

只能是抽象方法

默认修饰符：public abstract

接口和类之间的关系

实现类还可以在继承一个类的同时实现多个接口

类和类之间只能单继承，不能多继承，但是可以多层继承

如果重写的接口有重名的，重写一个就行

接口新增方法

默认方法

默认方法需要用default修饰，不需要在前面加public修饰，因为系统会自动在前面加上public修饰

public interface A {
    default void test1() {
        //方法内容
    }
}
注意：默认方法是实例方法，也就是对象的方法，但由于接口的对象不能直接调用，所以需要先创建类来继承这个接口，再去通过创建这个类的对象来使用接口中的方法。

public class B implements A {

}

public class Main {
    public static void main(String[] args) {
        B b = new B();
        b.test1();
    }
}

静态方法

必须使用static修饰

public interface A {
    static void test3() {
       //方法内容 
    }
}

static方法就可以在外部class直接调用了，无需创建一个新的对象

public class Main() {
    public static void main(String[] args) {
        A.test3();
    } 
    }

私有方法

  1. 必须使用private来修饰

  2. 注意：JDK9开始才支持

  3. “`java
    public interface A {

    private void test2() {
    //方法内容

    }
    “`

内部类

在一个类的里面，再定义一个类

成员内部类

写在成员位置的，属于外部类的成员

使用private 修饰 外界不能直接获取内部类，在外部类中提供一个方法返回内部类

静态内部类

特殊的成员内部类

创建静态类：

Outer.Inner oi=new Outer.Inner()

匿名内部类

隐藏了名字的内部类，可以写在成员位置，也可以写在局部位置

new 接口或类(){

重写方法

}

当方法的参数是接口或者类时，以接口为例，可以传递这个接口的实现类对象，如果实现类只使用一次，可以用匿名内部类简化代码

常用API

Math

public static void main(String[] args) {


        System.out.println(Math.abs(-2147483648));
        //向上取整

        System.out.println(Math.ceil(12.5));
        //去尾法

        System.out.println(Math.floor(12.34));

        //四舍五入
        System.out.println(Math.round(12.54));
        System.out.println(Math.round(12.33));

        //两个数最大/小值
        System.out.println(Math.max(10,20));
        System.out.println(Math.min(10,20));

        //次幂
        System.out.println(Math.pow(2,2));

        //开根
        System.out.println(Math.sqrt(4));

    }

System

public static void main(String[] args) {


        long l=System.currentTimeMillis();
        System.out.println(l);

        int[] arr1={1,2,3,4,5,6,7};
        int[] arr2=new int[7];

        System.arraycopy(arr1,0,arr2,0,7);
        for(int i=0;i<arr2.length;i++){
            System.out.println(arr2[i]);
        }
        System.out.println(l);
    }

BigInteger

public class BigInteerDemo1 {
    public static void main(String[] args) {
        //随机大整数
        BigInteger bd1=new BigInteger(4,new Random());
        System.out.println(bd1);

        //获取指定大的整数
        BigInteger bd2=new BigInteger("100");
        System.out.println(bd2);

        //指定进制的大整数
        BigInteger bd4=new BigInteger("100",2);
        System.out.println(bd4);

        //静态获取
        BigInteger  bd5=BigInteger.valueOf(100);
        System.out.println(100);

        BigInteger bd6=BigInteger.valueOf(1);
        BigInteger bd7=BigInteger.valueOf(2);
        BigInteger result=bd6.add(bd7);
        System.out.println(result);

    }
}

Screenshot_20250919_093612_tv.danmaku.bili

BigDecimal

public static void main(String[] args) {
        //不建议使用
        BigDecimal bd1=new BigDecimal(0.02);
        BigDecimal bd2=new BigDecimal(0.09);
        System.out.println(bd1);
        System.out.println(bd2);

        BigDecimal bd3=new BigDecimal("0.09");
        System.out.println(bd3);
        BigDecimal bd4=new BigDecimal("0.02");

        BigDecimal bd5=BigDecimal.valueOf(10);
        System.out.println(bd5);
    }

正则表达式

作用一：检验字符串是否满足规则

作用二：在一段文本中查找满足的内容Screenshot_20250919_103511_tv.danmaku.bili

数据爬取

public class PACHONG {
    public static void main(String[] args) {
        String str="Java自从95年问世以来，经历了许多版本，目前企业中用的最多的是Java8和Java11"+"下一个长期支持版本是Java17";

        Pattern p=Pattern.compile("Java\\d{0,2}");
        //获取文本匹配器的对象
        Matcher m=p.matcher(str);
        //寻找是否有满足规则的字串
        while(m.find()){
            String s=  m.group();
            System.out.println(s);
        }
    }

函数式编程

是一种思想特点

面向对象：先找对象，让对象做事情

Java 8 在java.util.function包下预定了大量的函数式接口供我们使用，常用如下：

  • Supplier接口
  • Consumer接口
  • Predicate接口
  • Function接口

函数式接口：有且仅有一个抽象方法的接口

Java中的函数式编程体现就是Lambda表达式，所以函数式接口就是可以使用于Lambda使用的接口

只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导

Supplier接口

  • T get()：获得结果
  • 该方法不需要参数，它会按照某种实现逻辑（由Lambda表达式实现)返回一个数据
  • Supplier 接口也被称为生产型接口，如果我们指定了接口的泛型是什么类型，那么接口中的get方法就会生产什么类型的数据供我们使用

Consumer接口

Consumer：包含两个方法

void accept(T t)：对给定的参数执行此操作
default Consumer andThen(Consumer after)：返回一个组合的Consumer,依次执行此操作，然后执行after操作
Consumer 接口也被称为消费型接口，它消费的数据类型由泛型指定

public class ConsumerDemo {
    public static void main(String[] args) {
        String[] arr = new String[]{"abc,30", "cbd,35", "dna,33"};
        printInfo(arr, s -> System.out.print("姓名：" + s.split(",")[0] + ","), s -> System.out.println("年龄：" + Integer.parseInt(s.split(",")[1])));
    }
private static void printInfo(String[] arr, Consumer<String> consumer1, Consumer<String> consumer2) {
    for (String s : arr) {
        consumer1.andThen(consumer2).accept(s);
    }
}

Predicate接口

image-20251211185139740

Function接口

image-20251211185551756

public class FunctionDemo {
public static void main(String[] args) {
convert(“100”, s -> Integer.parseInt(s));
convert(“100”, Integer::parseInt);

    convert(100, i -> String.valueOf(100 + i));

    convert("100", s -> Integer.parseInt(s), i -> String.valueOf(i + 566));

}

//定义一个方法，把一个int类型的数据加上一个整数之后，转为字符串在控制台输出
private static void convert(String s, Function<String, Integer> function) {
    Integer i = function.apply(s);
    System.out.println(i);
}

//定义一个方法，把一个int类型的数据加上一个整数之后，转为字符串在控制台输出
private static void convert(int i, Function<Integer, String> function) {
    String s = function.apply(i);
    System.out.println(s);
}

//定义一个方法，把一个字符串转换为int类型，把int类型的数据加上一个整数之后，转为字符串在控制台输出
private static void convert(String s, Function<String, Integer> function1, Function<Integer, String> function2) {
    String ss = function2.apply(function1.apply(s));
    System.out.println(ss);
}

}

Lambda表达式

注意：

Lambda表达式可以用来简化匿名内部类的书写

Lambda表达式只能简化函数式接口的匿名内部类的写法

函数式接口：

有且只有一个抽象方法的接口叫做函数式接口，接口上方可以加@Functionalinterface注解

基本作用：

简化函数式接口的匿名内部类写法

作用前提：

必须是接口的匿名内部类，接口中只能有一个抽象方法

Lambda的好处：

是一个匿名函数，我们可以把Lambda表达式理解为一段可以传递的代码，它可以写出更简洁，更灵活的代码，作为一种更紧凑的代码风格，使java语言的表达能力得到了提升

public static void main(String[] args) {
//        method(new Swim() {
//            @Override
//            public void swimming() {
//                System.out.println("正在游泳");
//            }
//        });
//    }
        //使用Lambda表达式进行改写
        method(()->{
            System.out.println("正在游泳");
        });


    }
    public static void method (Swim s){
        s.swimming();
    }
    @FunctionalInterface
    interface Swim {
        public abstract void swimming();
    }

省略写法

  1. 参数类型可以省略不写
  2. 如果只有一个参数，参数类型可以忽略，同时（）也可以忽略
  3. 如果Lambda表达式的方法体只有一行，大括号，分号，return可以省略不写，需要同时省略

相关条目

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注