【JAVA】类和对象，继承，多态，抽象类，接口

已于 2023-10-12 00:30:25 修改
阅读量209 收藏 11
点赞数 15
分类专栏： # JAVA 文章标签： java 开发语言
于 2023-09-01 17:22:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/partworld/article/details/132566439
版权

❤️ Author： 老九
☕️ 个人博客：老九的CSDN博客
🙏 个人名言：不可控之事 乐观面对
😍 系列专栏：

文章目录

什么是类，对象

因为计算机并不能像我们人这样去理解世界上的东西，所以为了更好的编辑，就抽象出了类和对象。类就是把功能放在一起，然后由一个人去调用这个功能，然后再编辑对应的功能。调用者就是对象的实现者

类和类的实例化

类是一类对象的统称，对象就是这一类具体化的实例
创建类的关键字：class
举例：我们坐年糕的模子就是一个类，而通过这个模子可以做出月饼。在这个例子当中，类就是模具，年糕就是实例化的对象。一个类可以实例化很多对象。举例：

class Person {
    public String name;
    public int age;
}
public static void main1(String[] args) {
    Person person1 = new Person();
    Person person2 = new Person();
    Person person3 = null;
}

Person 就是一个类，里面的 name 和 int 就是类的成员（字段）。这里的 person1 就是引用，指向的是后面 new 的对象，因为是引用，所以也可以指向 null 。person3 就是指向空（null）引用。person1 person2 person3 就是实例化的对象。

字段的初始化

字段就是类里面的成员。在创建这些成员的时候就可以初始化。例如：

class Person {
    public String name = "Lockey";
    public int age = 10;
}

类中实现方法

class Person {
    public String name;
    public int age;
    public void print() {
        System.out.println("姓名："+name+" 年龄："+age);
    }
}
public static void main(String[] args) {
    Person person1 = new Person();
    person1.name = "Lockey";
    person1.age = 10;
    person1.print();
}

static 静态关键字

static 可以修饰方法，属性。要注意的是：static 修饰的变量通过类名访问。

class Person {
    public int a;
    public static int count;
}
public static void main(String[] args) {
    Person person1 = new Person();
    person1.a++;
    person1.count++;
    System.out.println(person1.a);
    System.out.println(Person.count);
    Person person2 = new Person();
    person2.a++;
    person2.count++;
    System.out.println(person2.a);
    System.out.println(person2.count);
}

在这里插入图片描述
如图，count 第二次输出为 2 。这是因为 conut 是被 static 修饰的变量，被 static 修饰之后就变成了常量，就在静态区了。所以每个引用当中调用的 count 没变。所以第二次改变 count 的值的时候，就变成 2 了。当 static 修饰方法的时候，无需再创建对象，直接拿类名调用就行了。举例：

class Person {
    public static int count;
    public static void change() {
        count = 100;
    }
}
public static void main(String[] args) {
    Person.change();
    System.out.println(Person.count);
}

在这里插入图片描述
通过类名的调用直接访问 static 修饰的变量。

封装

因为代码实现的软件很复杂，所以就出现了类，但是为了阅读性更高，就出现了封装。就是把一个类的内容实现为只剩一个或几个接口，方便类的调用者访问，这样就降低了代码的复杂程度。

private 封装

private 就是修饰成员变量或方法的关键字，被 private 修饰之后，就不能被类外的调用者访问了。所以就可以配合 public 来实现对外的接口。例如：

class Person {
    private String name = "Lockey";
    private int age = 10;
    public void print() {
        System.out.println("名字是："+name+" 年龄："+age);
    }

    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;
    }
}
class test {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.getAge());
        person.print();
    }
}

在这里插入图片描述
这里就是利用 private 封装属性，使其只能在类内被访问到。而提供的 public 接口，就让类的调用者在类外就可以访问到了。所以在类外直接调用 print 方法就好了。

setter 和 getter 方法

当我们把字段（name age）设置为 private 属性时，就无法在类外进行初始化了，所以就又出现了新的方法：

class Person {
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name1) {
        name = name1;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age1) {
        age = age1;
    }
    public void print() {
        System.out.println("名字是："+name+" 年龄："+age);
    }
}
public static void main(String[] args) {
    Person person = new Person();
    person.setName("Lockey");
    person.getName();
    person.setAge(10);
    person.getAge();
    person.print();
}

在这里插入图片描述
这里就是调用 getter 和 setter 方法，在类外进行访问，因为 private 对 name 和 age 做了封装。

构造方法

方法名和类名是相同的，且构造方法没有返回值。调用完构造方法之后，对象才会产生。

一个对象的产生：
1 为对象分配内存。
2 调用合适的构造方法。

class Person {
    public Person() {
        System.out.println("Person 不带参数的构造方法");
    }
}
public static void main(String[] args) {
    Person person = new Person();
}

在这里插入图片描述
这里就是实例化类的对象的时候调用的构造方法，因为我们自己写了构造方法，所以这里就调用我i们写过的。就输出了如图所示的内容。需要注意的是：如果没有实现如何的构造方法，编译器会帮我们默认生成有个不带参数的构造方法。也就是说，一个类，至少会有一个构造方法。
除了上面这种构造方法，我们还能写带有参数的构造方法。例如：

class Person {
    private String name;
    public Person(String name1) {
        name = name1;
        System.out.println("Person(String) 带一个参数的构造方法");
    }
}
public static void main(String[] args) {
    Person person = new Person("Lockey");
}

在这里插入图片描述
如图：在类初始化的时候，传入参数 “Lockey” 在类实例化的时候就是调用有参数的构造方法。既然能传参数，那是否可以传多个参数呢？答案是可以的。例如：

class Person {
    private String name;
    private int age;
    public Person(String name1, int age1) {
        name = name1;
        age = age1;
        System.out.println("Person(String, int) 带两个参数的构造方法");
    }
}
public static void main(String[] args) {
    Person person = new Person("Lockey",10);
}

在这里插入图片描述
如图，调用的就是传了两个参数的构造方法。通过观察上面的例子，我们可以发现：构造方法也是支持重载的。

this关键字

在类当中，this 表示当前对象的引用（不是当前对象），可以通过 this 来访问类当中的字段和方法。用 this 的话，会降低出现 bug 的概率，并且增加代码的可读性。例如使用 getter 和 setter 的时候，就可以用 this ，能多用 this 就多用 this 。

class Person {
    private String name;
    private int age;

    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;
    }
}

继承

在创建的类当中，是为了给一些抽象的事物提供一些方法。如果一些类、一些食物有共同的属性，那么就可以把这些属性封装为一个类。然后其它事物有这个属性的时候，就去继承这个类。通过 extends 关键字去继承。就比如说：猫和鸟，它们的共同特点都有名字和吃。所以就可以把名字和吃放在一个类里面。然后让它们去继承，降低代码量。把被继承的这个类叫做 Animal 可以发现猫和鸟对于 Animal 都是一种 is-a 的关系。在继承的时候，也会继承父类（Animal）的字段和方法。

class Animal {
    public String name;
    public Animal(String name) {
        this.name = name;
    }
    public void eat(String food) {
        System.out.println(this.name + "正在吃" + food);
    }
}
class Cat extends Animal {
    public Cat(String name) {
        // 使用 super 调用父类的构造方法.
        super(name);
    }
}
class Bird extends Animal {
    public Bird(String name) {
        super(name);
    }
    public void fly() {
        System.out.println(this.name + "正在飞 ︿(￣︶￣)︿");
    }
}
public class Test4 {
    public static void main(String[] args) {
        Cat cat = new Cat("小黑");
        cat.eat("猫粮");
        Bird bird = new Bird("圆圆");
        bird.fly();
    }
}

子类在调用父类的构造方法的时候，要用到 super 关键字。用 super 关键字去把参数传进去。运行结果如下：
在这里插入图片描述
bird 就是在 Animal 继承的基础上又扩展出了 fly 方法。
如果把 name 的 public 改成 private 那么子类就访问不到了：

class Animal {
    private String name;
    public Animal(String name) {
        this.name = name;
    }
    public void eat(String food) {
        System.out.println(this.name + "正在吃" + food);
    }
}

在这里插入图片描述

protected 关键字

因为把访问权限设置为 private 就会导致子类不能访问。如果是 public 就会导致失去封装的意义。所以就可以使用 protected 。因为对于类的子类和同一个包的其他类来说，protected 修饰的字段是可以访问的。

class Animal {
    protected String name;
    public Animal(String name) {
        this.name = name;
    }
    public void eat(String food) {
        System.out.println(this.name + "正在吃" + food);
    }
}
class Cat extends Animal {
    public Cat(String name) {
        // 使用 super 调用父类的构造方法.
        super(name);
    }
}
class Bird extends Animal {
    public Bird(String name) {
        super(name);
    }
    public void fly() {
        System.out.println(this.name + "正在飞 ︿(￣︶￣)︿");
    }
}
public class Test4 {
    public static void main(String[] args) {
        System.out.println("保护权限下的访问");
        Cat cat = new Cat("小黑");
        cat.eat("猫粮");
        Bird bird = new Bird("圆圆");
        bird.fly();
    }
}

在这里插入图片描述

java对于字段的方法的四种访问权限

private: 类内部能访问, 类外部不能访问
默认(也叫包访问权限): 类内部能访问, 同一个包中的类可以访问, 其他类不能访问.
protected: 类内部能访问, 子类和同一个包中的类可以访问, 其他类不能访问.
public : 类内部和类的调用者都能访问

在这里插入图片描述

final关键字

之前学过，用 final 来修饰常数的时候，这个数不能被修改。所以用 final 来修饰类的时候，此时被修饰的类就不能被继承。

final class Animal {
    public String name;
    public Animal(String name) {
        this.name = name;
    }
    public void eat(String food) {
        System.out.println(this.name + "正在吃" + food);
    }
}
class Cat extends Animal {
    public Cat(String name) {
        // 使用 super 调用父类的构造方法.
        super(name);
    }
}
class Bird extends Animal {
    public Bird(String name) {
        super(name);
    }
    public void fly() {
        System.out.println(this.name + "正在飞 ︿(￣︶￣)︿");
    }
}
public class Test4 {
    public static void main(String[] args) {
        Cat cat = new Cat("小黑");
        cat.eat("猫粮");
        Bird bird = new Bird("圆圆");
        bird.fly();
    }
}

在这里插入图片描述

多态

向上转型

在上一篇 包和继承 当中我们写继承的关系的时候，写了这样的代码：

Bird bird = new Bird("圆圆");

当然，我们也可以写成这样：

Bird bird = new Bird("圆圆"); 
Animal bird2 = bird;

或者下面这样：

Animal bird2 = new Bird("圆圆");

此时 bird2 就是一个父类（Animal）的引用，指向一个子类（Bird）的实例，这就是向上转型。就像可以把：你给笔记本电脑充电了吗？说成：你给电脑充电了吗？ 因为笔记本电脑也是电脑。
为什么叫向上转型：因为在程序设计当中，有很多场景。为了表示这种关系，就可以把他们的关系图画出来，父类通常在子类的上方。所以就叫做向上转型，表示往父类的方向转。

方法重写

子类实现了父类的同名方法，并且参数的类型和个数完全相同，就称之为：覆写/重写/覆盖

重写和重载完全不一样.。
普通方法可以重写, static 修饰的静态方法不能重写。
重写中子类的方法的访问权限不能低于父类的方法访问权限。
重写的方法返回值类型不一定和父类的方法相同(但是建议最好写成相同, 特殊情况除外)。

如果我们把子类当中的权限改成比父类小的话，就会报错。代码如下：

class Animal {
    public String name;
    public Animal(String name) {
        this.name = name;
    }
    public void eat(String food) {
        System.out.println("这里是动物");
        System.out.println(this.name + "正在吃" + food);
    }
}
class Bird extends Animal {
    public Bird(String name) {
        super(name);
    }
    private void eat(String food) {
        System.out.println("这里是小鸟");
        System.out.println(this.name + "正在吃" + food);
    }
}
public class Test4 {
    public static void main(String[] args) {
        Animal animal1 = new Animal("圆圆");
        animal1.eat("谷子");
        Animal animal2 = new Bird("扁扁");
        animal2.eat("谷子");
    }
}

在这里插入图片描述

重写和重载的区别

在这里插入图片描述

理解多态

学了向上转型，动态绑定，方法重写之后，我们就可以使用多态的形式来设计程序了，写一些弗雷可以兼容子类的代码。例如，打印多种形状：

class Shape {
    public void draw(){
        System.out.println("Shape::draw()");
    }
}
class Rect extends Shape{
    public void draw() {
        System.out.println("♦");
    }
}
class Flower extends Shape{
    //alt + insert 快捷键输出重写的方法
    @Override
    public void draw() {
        System.out.println("❀");
    }
}
class Triangle extends Shape {
    @Override
    public void draw() {
        System.out.println("🔺");
    }
}
class Cycle extends Shape {
    @Override
    public void draw() {
        System.out.println("●");
    }
}
public class Test {
    // 打印单个图形
    public static void drawShape(Shape shape) {
        shape.draw();
    }
    public static void main(String[] args) {
        Shape shape1 = new Flower();
        Shape shape2 = new Cycle();
        Shape shape3 = new Rect();
        drawMap(shape1);
        drawMap(shape2);
        drawMap(shape3);
    }
}

在这里插入图片描述
这里类的代码是由类的实现者写的，main 函数是由类的调用者写的。当类的调用者在写 drawMap 方法的时候，就会通过父类去看一个调用那个子类的方法。

多态的好处

1.进一步的封装，让类的调用者不知道类的细节
2.降低代码量，避免使用大量的if else
3.可扩展能力更强

super关键字

前面的代码调用的是子类的方法，如果要调用父类的方法就要用到 super 关键字。
1.使用了 super 来调用父类的构造器：

public Bird(String name) {
    super(name);
}

2.使用 super 关键字来调用父类的普通方法：

class Bird extends Animal {
    public Bird(String name) {
        super(name);
    }
    @Override
    public void eat(String food) {
        //在这里让子类调用父类的接口
        super.eat(food);
        System.out.println("我是一只小鸟");
        System.out.println(this.name + "正在吃" + food);
    }
}
public class test5 {
    public static void main(String[] args) {
            Bird bird = new Bird("xxn");
            bird.eat("ee");
    }
}

在这里插入图片描述

super和this的区别

在这里插入图片描述

抽象类

就像这个代码：

class Shape {
    public void draw(){
        System.out.println("Shape::draw()");
    }
}
class Rect extends Shape{
    public void draw() {
        System.out.println("♦");
    }
}
class Flower extends Shape{
    @Override
    public void draw() {
        System.out.println("❀");
    }
}
class Triangle extends Shape {
    @Override
    public void draw() {
        System.out.println("🔺");
    }
}
class Cycle extends Shape {
    @Override
    public void draw() {
        System.out.println("●");
    }
}
public class Test {
    public static void main(String[] args) {
        Rect rect = new Rect();
        Flower flower = new Flower();
        Triangle triangle = new Triangle();
        Shape[] shapes = {triangle,rect,triangle,rect,flower,new Cycle()};
        for (Shape s: shapes) {
            s.draw();
        }
    }
}

在这个打印图形的例子当中，可以看到父类的 shape 方法并没有实际作用，主要的工作都由子类完成了，像这些没有实际工作的方法，我们就可以把它设计成一个抽象方法，包含抽象方法的类叫做抽象类：

abstract class Shape{
    public abstract void draw();
}

在 draw 方法前面加上 abstract 关键字就变成了抽象方法，但是包含抽象方法的类，必须用 abstract 修饰。抽象方法不用具体实现，抽象类就是Shape，然后Shape下面有很多的具体实现的子类

使用抽象类的注意事项

1.抽象类不能直接实例化

public static void main(String[] args) {
    Shape shape = new Shape();
}

在这里插入图片描述
2.抽象方法是不能用 private 修饰的

abstract class Shape{
    private abstract void draw();
}

在这里插入图片描述
3.抽象类中可以包含其他的非抽象方法，也可以包含字段，这里的非抽象方法和普通方法是一样的，可以被重写，也可以被子类直接调用，但是一个普通类要继承抽象类，那么必须重写抽象类当中的所有抽象方法。

abstract class Shape{
    public void func() {
        System.out.println("func");
    }
    public abstract void draw();、
}
class Rect extends Shape {
    @Override
    public void draw() {
        System.out.println("♦"+a);
        super.func();
    }
}
public class Test {
    public static void drawMap(Shape shape) {
        shape.draw();
    }
    public static void main(String[] args) {
        Shape shape = new Rect();
        shape.func();
    }
}

抽象类的作用

抽象类存在的最大意义就是为了被继承，抽象类本身并不能被实例化，要想使用，只能创建该抽象类的子类，然后让子类重写抽象类中的抽象方法。

接口

接口是抽象类的更进一步，抽象类中还可以包含非抽象方法和字段。而接口中包含的方法都是抽象方法，字段只能包含静态常量。
在上面的打印图像代码当中，父类 shape 并没有包含别的抽象方法，所以就可以设计成一个接口。代码示例：

interface IShape {
    void draw();
}
class Cycle implements IShape {
    @Override
    public void draw() {
        System.out.println("○");
    }
}
public class Test5 {
    public static void main(String[] args) {
        IShape shape = new Cycle();
        shape.draw();
    }
}

在这里插入图片描述
这里应该注意的是：

使用接口的时候，要用 interface 定义。
接口中的方法一定是 public ，因此可以省略 public 。
接口中的方法一定是抽象方法，因此可以省略 abstract 。
Cycle 使用 implements 继承接口，此时表达的含义不再是“扩展”，而是“实现”。
静态常量代码当中的 public static final 关键字都可以省略
接口不能单独被实例化。

接口当中只能包含抽象方法，对于字段来说，接口中只能包含静态常量：

interface IShape {
    void draw();
    public static final int num = 10;
}

实现多个接口

有些时候我们需要让一个类同时继承多个父类，但是 Java 实现不了多继承。不过可以通过同时实现多个接口来达到多继承类似的效果。通过类来表示一组动物（通过接口来调用就不用关心引用是谁了）：

class Animal {
    protected String name;

    public Animal(String name) {
        this.name = name;
    }

}
interface IFlying {
    void fly();
}
interface IRunning{
    void run();
}
interface ISwimming{
    void swimming();
}
class Bird extends Animal implements IFlying{
    public Bird(String name) {
        super(name);
    }
    @Override
    public void fly() {
        System.out.println(this.name+"正在飞");
    }
}
class Frog extends Animal implements IRunning,ISwimming{
    public Frog(String name) {
        super(name);
    }
    @Override
    public void run() {
        System.out.println(this.name + "正在跑");
    }
    @Override
    public void swimming() {
        System.out.println(this.name+"在游泳");
    }
}
class Duck extends Animal implements IRunning,ISwimming,IFlying{
    public Duck(String name) {
        super(name);
    }
    @Override
    public void fly() {
        System.out.println(this.name+"正在飞");
    }
    @Override
    public void run() {
        System.out.println((this.name+"正在跑"));
    }
    @Override
    public void swimming() {
        System.out.println(this.name+"在游泳");
    }
}
class Roobot implements IRunning{
    @Override
    public void run() {
        System.out.println("机器人在跑");
    }
}
public class Test4 {
    public static void runFunc(IRunning iRunning){
        iRunning.run();
    }
    public static void swimmingFunc(ISwimming iSwimming){
        iSwimming.swimming();
    }
    public static void flyingFunc(IFlying iFlying){
        iFlying.fly();
    }

    public static void main(String[] args) {
        runFunc(new Duck("鸭子"));
        runFunc(new Frog("青蛙"));
        runFunc(new Roobot());
    }
}

在这里插入图片描述

接口间的继承

接口也可以继承一个接口（也叫扩展），达到复用代码的效果。也是使用 extends 关键字：

interface IA1 {
    void funcA();
}
interface IB1 extends IA1{
    void funcB();
}
//因为要拓展接口的功能 所以有 B 和 A 所以这俩的方法都有重写
class C implements IB1{
    @Override
    public void funcB() {
    }
    @Override
    public void funcA() {
    }
}

♥♥♥码字不易，大家的支持就是我坚持下去的动力♥♥♥
版权声明：本文为CSDN博主「亚太地区百大最帅面孔第101名」的原创文章

李小浦
关注
  • 15
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 11
    评论
专栏目录
【Java语法】包 继承 多态 抽象类 接口
耀的博客
03-20 9342
一、包 包 (package) 是组织类的一种方式. 使用包的主要目的是保证类的唯一性 将类将放到包中 基本规则 在文件的最上方加上一个 package 语句指定该代码在哪个包中. 如果一个类没有 package 语句, 则该类被放到一个默认包中 包的访问权限控制 如果某个成员不包含 public 和 private 关键字, 此时这个成员可以在包内部的其他类使用, 但是不能在包外部的类使用. 二、继承 继承 对共性的抽取，使用extends关键字进行处理，可以对代码重复使用 语
java面向对象—抽象类、接口与多继承
phphot
10-20 2821
有时候，我们可能想要构造一个很抽象的父类对象，它可能仅仅代表一个分类或抽象概念，它的实例没有任何意义，因此不希望它能被实例化。例如：有一个父类“水果（Fruit）”，它有几个子类“苹果（Apple）”、“橘子（Orange）”、“香蕉（Banana）”等。水果在这里仅仅只是作为一个分类，显然水果的实例没有什么意义（就好像一个人如果告诉你他买了一些水果但是却不告诉你是苹果还是橘子，你很难
Java中的抽象类和接口
热门推荐
日常学习记录、分享，愿我们都遇见更好的自己，与诸君共勉
04-15 4万+
各位铁汁们大家好呀！今天让我们继续学习java，看看java中的抽象类和接口到底是什么？ 里面也会讲到多态呀，一起来看看吧😉
Java基础 | 继承，多态，抽象类与接口
zszq111的博客
01-12 1877
继承，多态，抽象类和接口
Java的继承、多态及向上向下转型、 接口、抽象类
weixin_45600350的博客
09-16 186
继承: 为了提高代码的复用性 延续+扩展 父类:子类的共性 子类就可以使用父类中的成员 多态:在继承的基础之上及方法的重写,父类引用指向子类类型的对象,这就是多态的表现形式 父类引用只能使用父类中有的成员,子类独有的内容无法使用,但是可以通过向下转型来操作 可以提高代码的复用性,灵活性,扩展性,便于后期维护 转型 cast 小范围类型 变量 = (小范围类型)大范围类型的数据; //父类-&g...
接口，多态，抽象类，final
08-10
在 Java 编程语言中，接口、多态、抽象类和 final 是四个非常重要的概念，它们在面向对象编程（Object-Oriented Programming，OOP）中扮演着关键角色。 1. 接口 接口是 Java 中的一种特殊的抽象类，所有方法都是...
Java实验报告——类的继承、多态的应用
02-21
总结来说，这个实验报告通过实际编程练习，帮助我们巩固了Java中抽象类和抽象方法的定义，以及类的继承和多态性这两个核心概念。通过设计和实现学生管理类，我们可以更深入地理解这些概念在实际问题解决中的应用。
Java中的接口和抽象类用法实例详解
09-03
总的来说，抽象类和接口都是Java中实现抽象和多态的重要工具，它们帮助开发者创建更加模块化、可扩展的代码结构，提高代码的重用性和维护性。在实际开发中，根据具体场景和需求，合理地运用抽象类和接口，可以提升...
Java 面向对象（继承、多态、接口、异常）.ppt
08-21
掌握类的继承、方法重写、super关键字的使用、final关键字、抽象类和接口、多态的使用以及异常的处理方式 熟悉面向对象继承和多态的概念
Java多态和实现接口的类的对象赋值给接口引用的方法(推荐)
08-31
Java的多态性是面向对象编程的一个核心特性，它允许我们使用父类（或接口）的引用指向子类（或实现接口的类）的对象。这样做的好处在于代码的灵活性和可扩展性，使得程序能够处理多种不同的对象类型，而不必关心具体...
Java-Lambda
最新发布
lizhiwei21的博客
07-21 174
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 494
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1173
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 1144
JVM-垃圾回收与内存分配
【Java算法】前缀和 下
2302_79806056的博客
07-18 1066
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
华为OD机试 - 分披萨 - 递归（Java 2024 D卷 200分）
学Java，找哪吒
07-21 518
递归算法通过函数调用自身解决问题，每次递归调用都处理问题的一个子部分，直到达到基准条件，从而构建最终解。
【Java并发编程之美 | 第三篇】Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
踢桃的成长之路
07-21 550
Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
对androidTestDebug 产物进行重新签名
shuizhizhiyin的专栏
07-19 486
在运行 gradle assembleAndroidTestDebug 任务后，自定义的 reSignAndroidTestDebug 任务将会被执行，并对子模块的 androidTestDebug 产物进行重新签名。your_keystore_path.jks、your_keystore_password、your_key_alias 和 your_key_password 需要替换为你的实际路径和密码。如果需要对其他子模块的产物进行重新签名，可以根据需要创建不同的自定义任务。// 设置密钥库密码。
每 日练 习
m0_67187271的博客
07-19 1025
正确答案：C 解析：是正确的，这是最基本的类定义形式，没有继承任何类，也没有实现任何接口。也是正确的，这里定义了一个名为x的类，它继承了名为y的类。同样是正确的，这里定义了一个公共类x，它继承了Applet类，这在Java中是合法的，尤其是在创建GUI应用程序时常见。是不正确的，因为在Java中，我们不能使用static关键字来修饰一个类的定义。static关键字只能用于类的方法、变量或者是内部类（即嵌套类），但不能用于顶级类（非嵌套类）。所以，这个选项是错误的。因此，正确答案是C。
Java类与对象基础：理解抽象、封装、继承和多态
通过示例程序展示了如何创建和使用对象，同时讲解了抽象、封装、继承和多态等核心概念。 在Java编程中，类与对象是面向对象编程的基础。类是对具有共同属性和行为的对象的抽象，它定义了对象的状态（属性）和行为...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 11
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

李小浦

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值