java基础5-面向对象的三大特征

于 2024-07-30 19:54:51 发布
阅读量399 收藏 12
点赞数 19
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhaogodzero/article/details/140732638
版权

1.封装

1.1广义封装和狭义封装（java）

封装，单词Encapsulation。

广义的封装：将一块经常要使用的代码片段，定义到方法中，是封装。将多个方法和多个状态数据定义到类体中，也是一种封装。

1.2 java封装（狭义封装）

封装的原因：

        一个类中的某一些属性，不希望直接暴露给外界，让外界直接操作。因为如果让外界直接操作的话，对 这个属性进行的值的设置，可能不是我们想要的（可能不符合逻辑）。此时就需要将这个属性封装起来，不让外界直接访问。

封装的方法 ：

  1. 为了不让外界直接访问某些属性，用关键字private修饰这些属性。
  2. 提供共有的getter/setter的方法，用来操作这个被私有化的属性。

为什么封装之后还要添加setter和getter方法？

可以通过指定的方式访问属性，在这些方法中，可以添加一些数据处理操作。

 测试代码（主类部分）：

public class APerson {
    // 成员变量私有化
    private String name;
    private int age;
    private char gender;

    //无参构造器
    public APerson(){}

    //全参构造器
    public APerson(String name, int age, char gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    //为每个成员变量，提供getter/setter方法

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age > 0 && age <= 120) {
            this.age = age;
        }else{
            System.out.println("--您赋值的年龄不合法--"+age);
        }
    }

    public char getGender() {
        return gender;
    }

    public void setGender(char gender) {
        if(gender == '男' || gender == '女'){
            this.gender = gender;
        }else{
//            System.out.println("--您赋值的性别不合法，需要汉字'男'或'女'--");
            //如果赋值有问题，可以使用下面的方式让程序中断，并进行提示
            throw  new RuntimeException("您赋值的性别不合法，需要汉字'男'或'女'--");
        }
    }
}

测试代码（测试部分测试类）

public class APersonTest {
    public static void main(String[] args) {
        //创建对象
        APerson p1 = new APerson();
        //p1.name = "小明";   name私有化了，就不可以直接访问
        //调用公有方法区访问
        p1.setName("小明");
        p1.setAge(18);
        p1.setGender('女');
        //System.out.println(p1.name);  也不能直接访问，需要调用公有的方法
        System.out.println(p1.getName());
        System.out.println(p1.getAge());
        System.out.println(p1.getGender());

        p1.setGender('m');
        System.out.println(p1.getGender());
    }
}

注意。setter/getter方法在idea中有快捷生成方式，如下图所示。

1.

2.

 点击后选中要生成方法的变量就完事了。

2.单例设计模式

2.1设计模式简介

        设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的代码设计的经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。

毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应，每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。

总体来说设计模式分为三大类：

  • 创建型模式(5种)：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

  • 结构型模式(7种)：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

  • 行为型模式(11种)：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

只学习单例模式：

单例模式（Singleton Pattern）是一种常用的软件设计模式，属于创建型模式之一。它的目的是确保一个类只有一个实例，并提供一个全局访问点。

使用场景：

  • 频繁创建和销毁的对象：如果对象创建和销毁的成本较高，且在程序运行期间需要频繁访问，使用单例模式可以提高效率。

  • 控制资源访问：例如，数据库连接、日志对象、配置管理器等，这些资源通常希望在整个应用中只有一份实例。

  • 工具类：对于一些工具类，如缓存、对话框、注册表设置等，使用单例模式可以简化代码，避免重复实例化。

2.2单例的饿汉模式

  单例模式的饿汉模式

 1. 提供一个该类的，私有的，静态的属性， 并在静态代码块里赋值
 2. 提供一个私有的构造器， 避免外界直接调用构造器
 3. 提供一个公有的，静态的方法，来获取当前类的对象

 代码如下：

public class BSingleton {
    private static BSingleton instance; // instance 实例的含义

    static{
        instance = new BSingleton();
    }
    //构造器私有化
    private BSingleton(){}

    public static BSingleton getInstance(){
        return instance;
    }
}

2.3单例的懒汉模式

单例模式的懒汉模式

1.提供一个该类的，私有的，静态的属性。
2.提供一个私有的构造器，避免外界直接调用构造器。
3.提供一个共有的，静态的方法，来创建当前类的对象。如果对象不存在，说明对象还未创建。
4.懒汉模式，有线程安全隐患问题，比如两次调用的时候，都恰好执行到判断等于null。都会执行到创建实例那一行代码，那么就会在内存中创建出来两个对象。

代码如下：

public class CSingleton {
    //私有化的静态变量
    private static CSingleton instance;
    //私有化构造器
    private CSingleton() {

    }
    //公有的静态方法，用于获取对象
    public static CSingleton getInstance() {
        //如果静态变量里没有地址，说明还未创建对象。
        if(instance == null) {
            //创建对象，将地址存入静态变量
            instance = new CSingleton();
        }
        //返回对象的地址，之前有，就用之前的，没有，就用新的。
        return instance;
    }

}

2.4 两者的比较 

基本都是一样的，都可以获取到一个类的唯一的对象。

1 、在没有使用获取当前类对象之前，懒汉式单例比饿汉式单例在内存上有较少的资源占用。

2 、懒汉式单例在多线程的环境下有问题。需要考虑线程安全(学到线程再说)

3. 继承

3.1继承的简介

        继承是面向对象最显著的一个特征。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。

        已有的类，叫父类，又叫基类，超类。 派生出来的新类，叫子类，也叫派生类。

使用关键字extends 来表示子类继承了父类，语法如下：

修饰词 class  子类名  extends 父类名{
     //子类的类体
}

例子：

 class A{}  //父类
class B extends A{}  //B是A的子类
class C extends B{}  //C是B的子类

3.2 继承的特点

  1. Java只支持单继承，即一个类只能有一个父类；但是一个类可以有多个子类。
  2. java支持多重继承，即一个类在继承自一个父类的同时，还可以被其他类继承。 可见继承具有传递性
  3. 子类继承了父类的所有成员变量和方法，包括私有的（只不过没有访问权限），当然也包括静态成员。
  4. 子类不会继承父类的构造方法，只能调用父类里的构造方法，并且一定至少有一个子类构造器调用了父类的构造器。
  5. 子类在拥有父类的成员的基础上，还可以添加新成员。

 如下图所示：

 3.3 继承中的构造器

 

一个对象在实例化的时候，需要在堆上开辟空间，堆中的空间分为两部分，分别是从父类继承到的属性，子类特有的属性。而实例化父类部分的时候，需要调用父类中的构造方法。

值得注意的是，默认调用的是父类中的无参构造器。如果父类中没有无参构造器，那么子类需要显式调用父类中的某一个有参构造器。

在子类的构造方法中，使用 super(有参传参) 调用父类中存在的构造方法，而且 super(有参传参) 必须放在首行首句的位置上。因此super(有参传参)和this(有参传参)不能在一个构造器中共存。

 再重复一下：

构造器：

  •     子类不能继承父类的构造器
  •     子类的构造器中可以使用super(有参传参)进行显式的调用父类中的某一个构造器
  •     super(有参传参)和this(有参传参)一样，必须放在首行首句，因此不能并存。
  •     子类的构造器中，至少存在一个构造器调用了父类的构造器。
  •     为什么要至少有一个调用了父类的构造器：因为子类继承过来的属性需要初始化。

 代码（APerson类——父类）

public class APerson {
    private String name;
    private int age;
    private char gender;

    public APerson() {}
    public APerson(String name, int age, char gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

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

    public char getGender() {
        return gender;
    }

    public void setGender(char gender) {
        this.gender = gender;
    }
}

代码（Student——子类）

定义一个学生Student类型，将人的特征全部继承过来
学生类独有的特征：
    学号: studentId
    班级编号：classNumber

public class Student extends APerson{
    private String studentId;
    private String classNumber;

    //添加自己的构造器
    public Student(String studentId, String classNumber) {
//        super("小黑",10,'女');
        this.studentId = studentId;
        this.classNumber = classNumber;
    }
    public Student(String name,int age,char gender,String studentId,String classNumber) {
//        this.name=name;  父类里的name属性私有化，虽然子类继承了，但是不能直接访问。
//        setName方法是继承过来的，并且是公有的，因此可以直接使用
        this(classNumber,studentId);
        setName(name);
        setAge(age);
        setGender(gender);
//        this.studentId = studentId;
//        this.classNumber = classNumber;

    }

    public String getStudentId() {
        return studentId;
    }

    public void setStudentId(String studentId) {
        this.studentId = studentId;
    }

    public String getClassNumber() {
        return classNumber;
    }

    public void setClassNumber(String classNumber) {
        this.classNumber = classNumber;
    }
//添加toString方法：用来显示对象的属性值。
    public String toString() {
        return "name: "+getName()+"\nage: "+getAge()+"\ngender: "+getGender()+"\nstudentId: "+studentId+"\nclassNumber: "+classNumber;
    }
}

3.4 继承中的方法重写

        重写，叫做override。在子类中，对从父类继承到的方法进行重新的实现。 这个过程中，子类重写该方法，会覆盖掉继承自父类中的实现方法，因此，重写又叫做覆写。

为什么要重写

因为父类的方法逻辑不能满足子类的需求了，因此子类需要修改逻辑，也就是重写。

 重写的特点:

  • 子类只能重写父类中存在的方法。（不存在的就是子类自己的方法）
  • 重写时，子类中的方法名和参数要与父类保持一致。（区别于重载overload）
  • 返回值类型：必须和父类方法的返回值类型相同，或者是其子类型。
  • 访问权限：子类重写方法的访问权限必须大于等于父类方法的访问权限。

 代码部分：

package com.oop.day02._02Extend;

/*
演示：继承中的方法的重写特点。

 */
public class TDog extends Animal{
    public static void main(String[] args) {
        //创建了一个子类型对象
        TDog dog = new TDog();
        //调用继承过来的并且有访问权限的方法
        dog.motion();
    }


    //子类dog独有的功能
//    @Override//注解只能放在子类重写父类的方法的上面，可以用于检测是不是重写，不是重写，就报错。
    public void noise(){
        System.out.println("--汪汪汪汪--");

    }
    //子类将父类的方法，完全一模一样的写出来，就是重写的一种。
    @Override
    public void motion(){
        System.out.println("--运动中--");
    }
    //子类在重写父类方法时，返回值类型与父类中的方法返回值可以相同，也可以是其子类型：TDog就是Animal的子类型。
    @Override
    public TDog getMyclr(){
        return null;
    }

    //子类在重写父类的方法时，访问权限应该大于等于父类方法的去访问权限。
    @Override
    public String showInfo(){
        return null;
    }
    //自己独有的方法，只不过与继承过来的那个是重载关系
    public String showInfo(int a){
        return null;
    }

}


class Animal{
    private String color;

    //公有的，返回值void
    public void motion(){
        System.out.println("--运动中--");
    }
    //公有的 返回值Animal
    public Animal getMyclr(){
        return null;
    }
    //默认的，返回值String
    String showInfo(){
        return null;
    }

}

 关于注解@Override

        这个注解，用在重写的方法之前，表示验证这个方法是否是一个重写的方法。如果是，程序没有问题。如果 不是，程序会报错。  因为我们在进行方法重写的时候，没有什么提示的，因此，在进行重写之前，最好加上这个注解。

误区：加了@Override就是重写，没有加@Override就不是重写。 这种说法是错误的！ @Override只是进行的一个语法校验，与是不是重写无关。

 面试题 : 简述 Override 和 Overload 的区别

Override: 是重写，是子类对父类的方法进行重新实现。

Overload: 是重载，是对同一个类中的同名、不同参数方法的描述。

 3.5 Object类型

        Object类，是Java中的根类。所有的类都直接或者间接的继承自Object类。因为，所有的类都直接或者间接的继承自Object类，因此在Object类中定义的属性、方法，在所有的类中都有包含。 比如常用的方法 hashCode()，equals()，toString()，getClass()，wait()，notify()，notifyAll()等。

1）toString（）方法

源码如下：

public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

 该方法的作用是将对象的信息变成字符串。 Object里返回的是 “类名@16进制” 。这个返回结果意义不大。看不到对象的成员变量的信息。因次一般都需要重写。

该方法。在使用输出语句打印对象的变量时，会自动调用。

 重写：可以在idea里直接生成。

@Override
public String toString() {
   return "Teacher{" +"name='" + name + '\'' +", age=" + age +", gender=" + gender +'}';
}

 2) equals()方法

源码如下：

public boolean equals(Object obj){
   return this==obj;  //  == 比较的是地址值。  
}

上述的源码的意义所在：比较this和传进来的obj 是不是同一个对象，如果是，则返回true,不是的话，返回false。

而我们大多时候的需求，并不是比较是不是同一个对象，而是比较两个对象的属性值是否相同。 因此：自定义类型时，应该重写eqauls方法。

重写要遵循一些原则：

  1. 如果  obj = null，一定要返回false。
  2. 如果  obj = this，一定要返回true。
  3. 如果两个对象的类型不同，一定要返回false。
  4. 如果  a.equals(b) 成立，则  b.equals(a) 也必须成立。
  5. 如果  a.equals(b), b.equals(c) 成立，则  a.equals(c) 也必须成立。

代码：

public class Teacher {
    private String name;
    private int age;
    private char gender;

    public Teacher(){}
    public Teacher(String name, int age, char gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }
    //重写equals
    @Override
    public boolean equals(Object obj){
        if(obj == null)
            return false;
        if(obj == this)
            return true;
        if(obj instanceof Teacher) {
            Teacher t = (Teacher) obj;
            return this.name.equals(t.name) && this.age == t.age&& this.gender == t.gender;
        }

        return false;
    }

 重写equals方法
    1.判断一下，传入的是不是null
    2.判断一下，传入的是不是自己
    3.判断一下，是不是同类型，如果是就转成同类型进行比较
    4.其他任何情况，都返回false。 

 3)hashCode()方法

该方法返回的是一个int类型的值。 表示对象在内存堆中的一个算法值。   在自定义类型时，一般都需要重写该方法

4)getClass()方法

方法原型 : public final native Class<?> getClass();
方法作用 : 获取一个用来描述指定类型的Class类对象。获取一个指定的对象的类型。 这个方法，不能被重写。

//通过对象调用getClass(),来获取Teacher对应的描述类的副词昂
        Class<? extends Teacher> aClass=t1.getClass();
        System.out.println(aClass.getName());
        //获取类里的所有属性
        Field[] fields =aClass.getDeclaredFields();
        for(Field f:fields){
            System.out.println(f.getName());
        }

3.6 final修饰词

        final是java语法中的修饰词，可以用来修饰类，属性，方法，局部变量。 final是“最后，最终”的含义。

特点：

  • 修饰类时，类不能再有子类，即不能被继承， 比如String, 八大基本数据类型的包装类
  • 修饰属性：只能赋值一次，即要么直接初始化，要么在构造器初始化。
  • 修饰方法：final修饰的方法，不能被重写。
  • 修饰局部变量， 只能赋值一次，不能第二次赋值。
public class Cat {
    private final String name;
    public Cat(String name) {
        this.name = name;
    }

    public final int sum(int a,int b){
        //测试final修饰局部变量
        final int x;
        x = 100;
//        x = 101;

        return a+b;
    }
    //下面的方法：给name赋值已经不是初始化了，因为想要执行该方法，那么构造器一定先执行了。
//    public void setName(String name) {
//        this.name=name;
//    }
}
//不能继承Cat，因为Cat是final修饰的
//class ACat extends Cat{}

//探究一下父类里的方法被final修饰，还能不能参与重写
class DCat extends Cat{
    public DCat(String name) {
        super(name);
    }
    //不能重写父类里的final方法，否则报错。
//    public int sum(int a, int b){
//        return a+b;
//    }
}

上述代码注意注释部分的解释。

3.7 static修饰词

static修饰的内容，都是属于公有资源，不属于对象，而是属于类的，因此都是类名调用。

static 修饰词
1.修饰成员变量：
        静态成员变量，属于类的，公共资源，使用类名.调用
        注意:可以使用引用变量.调用，但是不合理，因为不属于对象。
2.修饰方法：
        静态方法，属于类的，公共资源，使用类名.调用
        注意:可以使用引用变量.调用，但是不合理，因为定义的方法不属于对象，属于大家。
        静态方法中，不能直接访问非静态成员。
        static方法不能被重写，但是子类里可以写跟父类里一模一样的静态方法，不是重写，各是各的
3.修饰代码块，
        静态代码块，类加载时只执行一次。通常用于加载静态资源：图片，音频等

4.修饰类：
        可以修饰内部类。

 代码解释：

public class MyUtil {
    private String name;
    //定义一个水桶的容量，单位是1L
    public static int contain = 18;

    //如果想要达到每时每刻看到的共有资源都是一样的，那么就应该再加上使用final修饰，即常量。
    public static final double PI = 3.14159265358979323846;
    //final 和 static顺序无所谓。
    public void addContain() {
        this.contain++;
    }
    public void subContain() {
        this.contain--;
    }
    public static void sum(int a, int b) {
        //不能直接访问非静态成员
//        this.aaaa;
//        addContain();
        contain = 19;

    }

    public static void main(String[] args) {
        MyUtil p1 = new MyUtil();
        //查看容量
        //使用变量调用，但是不建议。
        System.out.println("contain = " + p1.contain);

        p1.addContain();
        System.out.println("contain = " + MyUtil.contain);
        //注意：静态变量要使用类名.调用
        MyUtil p2 = new MyUtil();
        p2.subContain();

    }
}

class sub extends MyUtil {
//    @Override    添加注解后报错，因为static方法，不能被重写，但是子类里可以写跟父类里一模一样的静态方法，不是重写，各是各的
    public static void sum(int a, int b) {
        //不能直接访问非静态成员
//        this.aaaa;
//        addContain();
        contain = 19;

    }
}

4.多态 

多态：从字面上理解，就是多种形态，多种状态的含义，在这里，指的是一个对象具有多种形态的特点。说的再简单点，就是一个对象可以从一种类型转换为另外一种类型。有向上转型和向下转型两种形式

4.1向上转型（向上造型）

  • 方法：父类型的变量引用子类型的对象。
  • 向上转型肯定会成功，是一个隐式转换。
  • 向上转型后的对象，将只能够访问父类中的成员（编译期间，看变量类型）
  • 如果调用的是重写过的方法，那么调用的一定是重写过的方法（运行期间，看对象）
  • 应用场景：在定义方法时，形式参数是父类型的变量。这样更加灵活，可以传任意子类型的对象

 代码：（父类）

public class Animal {
    private String color;
    private String name;
    private int age;

    public Animal() {}

    public Animal(String color, String name, int age) {
        this.color = color;
        this.name = name;
        this.age = age;
    }

    //动物都会叫
    public void noise(){
        System.out.println("---------动物都会叫--------");

    }

}

class Dog extends Animal{
    public Dog(String color, String name, int age) {
        super(color, name, age);
    }

    public void noise(){
        System.out.println("-------汪汪汪-----");

    }
    public void LookHouse(){
        System.out.println("--看家--");
    }
}

class Cat extends Animal{
    public Cat(String color, String name, int age) {
        super(color, name, age);
    }
    public void noise(){
        System.out.println("----喵喵喵喵----");
    }
    public void catchMouse(){
        System.out.println("---抓老鼠---");
    }
}

 向上转型的代码测试：

public class AnimalTest {
    public static void main(String[] args) {
        Animal a1 = new Cat("baide","下滑",3);
        Animal a2 = new Dog("sad","白",10);
        a1.noise();//编译期间不会出现问题，因为父类型里面有该方法。运行期间执行的是对象的类型里的方法逻辑
//        a1.catchMouse();调用不到该方法，因为a1这个变量的类型里没有该方法，(编译期间看变量类型)

        test1(a1);
        test1(a2);
    }
    //测试：执行动物的叫声   这就是向上造型的优势所在，父类型的变量作为参数，更加灵活，可以传入不同的子类型对象。
    public static void test1(Animal an){
        an.noise();
    }
}

 

4.2 向下转型

父类型变量赋值给子类型的变量，需要强制转换，是一个显式转换。

多态的另外一种形式：向下转型。
        父类型的变量赋值给子类型的变量，需要强制转换。
        该操作可能会出现失败，失败的话，就会报异常；ClassCastException 类造型异常
         如果想要避免失败，可以使用 instanceof 关键字来进行判断：
                该变量指向的对象是否属于某一个类型。如果是，返回true，否则返回false

为什么向下转型： 前提，父类型的变量引用子类型的对象，但是父类型的变量调用不了子类里独有的功能，已经不能满足需求。

应用场景：
        多数情况下，定义方法时，形参都是父类型的变量，原因是可以接收任意子类型的对象
但是有时候，在这样的方法逻辑中，可能会用到该对象的独有功能，因此会涉及到向下转型。

向下转型代码：

public class AnimalTest2 {
    public static void main(String[] args) {
        Animal am = new Dog("yellow","大黄",5);
        am.noise();
        //调用一下对象的独有功能
//        am.LookHouse();//编译期间看变量类型，没有该方法，所以报错。
        //只能向下转型才可以
        Dog d =(Dog)am;
        d.LookHouse();
        //上述代码没有问题，但是在真正编程是，有可能写成如下代码：强制转换的类型不正确
        //编译期间，不报错。但是运行期间，就会报异常。
//        Cat c =(Cat)am;
//        c.catchMouse();
        //我们应该避免上述情况发生。只需要使用instanceof即可
        if(am instanceof Cat){//因为am指向的是一个Dog对象，不属于Cat类型，因此进不去分支。
            //所以避免了报错
            Cat c = (Cat)am;
            c.catchMouse();
        }
    }
}

 

十十一丶
关注
  • 19
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java语言基础-面向对象
12-21
Java语言基础-面向对象 Java语言是面向对象的编程语言 对象 对象：是构成系统的最基本的单位 属性：描述对象的静态特征（成员变量） 行为：描述对象的动态特征（成员方法和构造方法） 类是模型，对象是实例；类是...
第5章-JAVA面向对象编程基础.ppt
11-21
JAVA面向对象编程基础 JAVA面向对象编程是面向对象编程语言的基础，包含定义类、创建类的实例对象、构造函数、访问控制修饰符、静态属性和静态方法等内容。 一、定义类 在JAVA中，定义类使用class关键字，语法...
Java基础--------面向对象三大特征
詹煜彪9527
02-27 1万+
一. 封装 封装（Encapsulation）是面向对象的重要特征之一，它是由类来体现的，就是把对象的属性和方法结合成一个独立的整体，把过程和数据包围起来，并尽可能地将对象的内部实现细节进行隐藏，通过已经定义的接口来控制用户对类的修改和访问数据的程度，防止该类中的代码和数据被外部类所定义的代码随机访问。在Java中通过关键字 private 、protected 和 public 来实现封...
基于Java基础-面向对象实现植物大战僵尸简易版
热门推荐
weixin_43776741的博客
03-31 2万+
基于Java基础-面向对象实现植物大战僵尸简易版前言游戏设计游戏对象游戏内容游戏优化放置植物的优化移除植物的优化游戏可玩性的优化添加游戏背景音乐后续优化源码分享 前言 从零开始学习的Java的第一个月，在面向对象(OOP)的学习中，跟着讲师完成了飞机大战的游戏编码。第二个月开始接触API，心血来潮便结合API中的集合、多线程开始植物大战僵尸的编码，从游戏模式的设计到游戏内容的实现大约花费2个礼拜的...
java基础-面向对象
codeglory的博客
04-21 6211
java基础部分-面向对象的概念，类之间关系，并部分解释了UML类图
jmu-Java-03面向对象基础-05-覆盖
琉璃轻纱的博客
12-06 1602
PTA
java学习---面向对象基础
MTYSYS19990212的博客
05-07 2603
1、面向对象基础 1.1、 面向对象思想 1.1.1、 概述 面向对象(Object Oriented)是软件开发方法，一种编程范式。面向对象的概念和应用已超越了程序设计和软件开发，扩展到如数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。面向对象是一种对现实世界理解和抽象的方法，是计算机编程技术发展到一定阶段后的产物。 面向对象是相对于面向过程来讲的，面向对象方法，把相关的数据和方法组织为一个整体来看待，从更高的层次来进行系统建模，更贴近事物的自然运行模
Java基础（三）-面向对象基础
06-16
Java基础（三）-面向对象基础
完整版Java全套入门培训课件 Java基础 03-面向对象（共18页）.pptx
08-22
面向对象的三大特性包括封装、继承和多态，这些都是简化复杂问题和提高代码复用的关键。 封装是面向对象的核心概念之一，它意味着隐藏对象的内部细节，只对外提供公共接口供其他部分使用。这样做的好处包括隔离变化...
JAVA-面向对象基础-字符串-集合
09-27
观看黑马程序员Java零基础视频教学，从60P方法开始总结的知识集合，请使用Xmind打开，如果需要学习请配合视频打开：https://www.bilibili.com/video/BV17F411T7Ao
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
最新发布
qq_43700885的博客
07-29 271
1.导入hutool的maven依赖。2.复制一下代码执行。
golang 接口
m0_70982551的博客
07-24 1073
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 118
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 582
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件
weixin_43561432的博客
07-24 341
【代码】Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
訾博（ZiBo）的博客
07-27 710
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 395
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
Java修炼 2024.7.26 0:24
2301_80011650的博客
07-26 449
问题：编写一个方法，找出一个数组中的众数（出现次数超过数组长度一半的元素）。例如，输入 [2, 2, 1, 1, 2]，输出 2。编写一个方法，找出一个整数数组中的第二大元素。例如，输入 [3, 5, 1, 8, 7]，输出 7。例如，输入 5，输出 5。问题：编写一个方法，将给定的字符串逆转。问题：使用数组实现栈，并提供基本操作（push、pop、peek、isEmpty）。问题：实现一个单向链表，并提供基本的操作（添加、删除、查找元素）。问题：编写一个方法来查找一个给定字符串的所有子串。
新建springboot项目找不到java版本8?
weixin_74009895的博客
07-28 144
新建springboot项目找不到java版本8?
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值