当前位置： 首页 > news >正文

学习日志08 java

news 来源：原创 2025/5/17 7:47:12

1 对比代码哪个更好？

public void setName(String name)

{

this.name = name;

}

或者写

public void setname(String s){

name = s;

}

哪个更好？第一个好。

在 Java 中，通常推荐使用第一种方式，即遵循标准的 JavaBean 命名规范，使用 setName 方法。以下是详细对比和建议：

1. 第一种方式：setName(String name)

java

public void setName(String name) {this.name = name;
}
优点：
  • 符合 Java 标准命名规范：JavaBean 规范要求 setter 方法名以 set 开头，后跟首字母大写的属性名（如 name → setName）。这是 Java 社区广泛接受的做法，提高了代码的可读性和可维护性。
  • IDE 自动识别：大多数 IDE（如 IntelliJ、Eclipse）会自动识别这种命名方式，支持代码补全、自动生成 getter/setter 等功能。
  • 框架兼容性：许多 Java 框架（如 Spring、Hibernate）依赖于标准的 JavaBean 命名规范来进行属性注入和反射操作。

2. 第二种方式：setname(String s)

java

public void setname(String s) {name = s;
}
缺点：
  • 不符合命名规范：方法名 setname 中的 n 小写，违反了 JavaBean 的命名约定（属性名 name 对应的 setter 应为 setName）。
  • 可读性差：其他开发者可能会误解方法的意图，或认为这是一个自定义方法而非标准的 setter。
  • IDE 和工具支持不足：IDE 可能无法自动识别 setname 为 name 的 setter，导致代码补全、序列化等功能异常。

其他建议：

  1. 使用 this 关键字：
    第一种方式中使用 this.name = name 更清晰地表明是将参数赋值给当前对象的属性，避免变量名冲突。

  2. 参数名与属性名一致：
    推荐参数名与属性名保持一致（如 setName(String name)），这样代码更直观，也符合 Java 社区的习惯。

  3. IDE 自动生成：
    大多数 IDE 可以自动生成符合规范的 getter/setter，避免手动编写时出错。例如在 IntelliJ 中，右键点击类 → Generate → Getter and Setter。

结论：

推荐使用第一种方式（setName(String name)），因为它符合 Java 标准，提高了代码的可读性和兼容性。第二种方式虽然在语法上正确，但会给代码维护带来不必要的麻烦。

2 单独定义构造方法

在 Java 里，构造方法是一种特殊的方法，其主要作用是在创建对象时对对象的属性进行初始化。构造方法的名字必须和类名一样，而且没有返回类型（连 void 也不用写）。

3 怎么实现输入多行多组数据

我想要输入：

3

-5

但实际的代码运行里面输入了3 换行以后代码就跑了

package PTA_training.Demo3_2;import java.util.Scanner;/*
/*
7-2 正方形类
定义一个正方形类square，在次类中包括写内容：
定义成员变量边长private int edge;
定义方法：包括构造方法，setter getter方法，求面积方法等，要求如下所示：
定义正方形类的构造方法：在构造方法中给edge赋值为2，并添加System.out.println("this is constructor method");
为成员变量edge设置set方法，用来接收用户给edge的值，如果用户给的值<=0,则设置edge值为1
为成员变量edge设置get方法，用来返回edge的值
完成求面积方法，得到正方形的面积：public int getArea()
定义类Main，并在main方法中， 1.首先创建正方形对象s1，然后通过getEdge()方法输出edge的值，然后调用getArea方法求出s1的面积并输出
2.创建正方形对象s2,并通过键盘输入s2对象的边的值，然后通过getEdge()方法输出edge的值，然后调用getArea方法求出s1的面积并输出
输入格式:
输入在一行中给出边的值。
输出格式:
输出s1对象的边、输出s1对象的面积
输出s2对象的边、s2对象的面积
输入样例:
在这里给出一组输入。例如：
3
-5
输出样例:
在这里给出相应的输出。例如：
this is constructor method
s1:edge=2
s1:area=4
this is constructor method
s2:edge=3
s2:area=9
this is constructor method
s1:edge=2
s1:area=4
this is constructor method
s2:edge=1
s2:area=1*/
public class Main {public static void main(String[] args) {Scanner scanner =new Scanner(System.in);while (scanner.hasNext()){int inputEdge = scanner.nextInt();Square s1 = new Square();System.out.printf("s1:edge=%d%n",s1.getEdge());System.out.printf("s1:area=%d%n",s1.getArea());Square s2 = new Square();s2.setEdge(inputEdge);System.out.printf("s2:edge=%d%n",s2.getEdge());System.out.printf("s2:area=%d%n",s2.getArea());} scanner.close();}
}

给出的改进

package PTA_training.Demo3_2;import java.util.Scanner;public class Main {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);while (scanner.hasNext()) {int inputEdge = scanner.nextInt();Square s1 = new Square();System.out.printf("s1:edge=%d%n", s1.getEdge());System.out.printf("s1:area=%d%n", s1.getArea());Square s2 = new Square();s2.setEdge(inputEdge);System.out.printf("s2:edge=%d%n", s2.getEdge());System.out.printf("s2:area=%d%n", s2.getArea());}scanner.close();}
}

 4 关于abstract抽象类

在 Java 里，抽象类是一种无法被实例化的类，其存在意义在于为子类提供共同的属性与方法定义。下面为你详细介绍抽象类的关键特性和使用场景。

核心特点

  1. 不可实例化：抽象类没办法直接创建对象，必须通过子类来继承并实现其抽象方法。
  2. 抽象方法：抽象方法是没有具体实现的方法，仅包含方法签名，需要在子类中完成实现。
  3. 普通成员：抽象类中除了抽象方法，还能包含普通的字段、方法以及构造函数。
  4. 继承与实现：若子类继承了抽象类，就必须实现其中所有的抽象方法，否则该子类也得被声明为抽象类。

基本语法

下面是抽象类的基本语法示例：

java

public abstract class Animal {// 普通字段protected String name;// 构造函数public Animal(String name) {this.name = name;}// 普通方法public void eat() {System.out.println(name + "正在吃东西");}// 抽象方法public abstract void sound();
}// 子类实现抽象方法
public class Dog extends Animal {public Dog(String name) {super(name);}@Overridepublic void sound() {System.out.println(name + "汪汪叫");}
}// 使用示例
public class Main {public static void main(String[] args) {// Animal animal = new Animal("动物"); // 错误，无法实例化抽象类Dog dog = new Dog("小狗");dog.eat();    // 输出: 小狗正在吃东西dog.sound();  // 输出: 小狗汪汪叫}
}

主要作用

  1. 定义通用接口：借助抽象方法，能够强制要求子类实现特定的功能。
  2. 代码复用：可以将子类的共同行为提取到抽象类中，避免代码重复。
  3. 多态应用：通过抽象类的引用指向子类对象，能实现运行时的多态。

注意要点

  1. 抽象类的设计：设计抽象类时，要保证其具有足够的通用性，同时又为子类提供了具体实现的空间。
  2. 方法访问权限：抽象方法默认是public的，也可以显式声明为protected，但不能是private。
  3. 与接口的差异：抽象类既可以包含抽象方法，也能有普通方法和字段；而接口中的方法默认全是抽象的（Java 8 及以后版本允许有默认方法）。

典型应用场景

  • 模板方法模式：在抽象类中定义算法的骨架，把具体步骤交给子类去实现。
  • 工厂模式：利用抽象类创建对象，具体的创建逻辑由子类完成。
  • 框架设计：在框架里定义一些抽象类，让开发者通过继承来实现具体的业务逻辑。

5 关于super关键字

在 Java 中，super关键字主要用于引用父类的成员（包括构造方法、字段和方法）。它在继承关系中起着重要作用，能够帮助子类访问和调用父类的相关内容。下面详细介绍super关键字的用法和注意事项。

子类调用父类。

1. 调用父类的构造方法

  • 语法：super([参数列表])
  • 作用：在子类的构造方法中，可以使用super()调用父类的构造方法，必须放在子类构造方法的第一行。
  • 示例：

    java

    class Animal {protected String name;public Animal(String name) {this.name = name;}
}class Dog extends Animal {private String breed;public Dog(String name, String breed) {super(name); // 调用父类的构造方法this.breed = breed;}
}

2. 访问父类的字段

  • 语法：super.字段名
  • 作用：当子类中定义了与父类同名的字段时，可以使用super来引用父类的字段。
  • 示例：

    java

    class Parent {protected int value = 10;
}class Child extends Parent {private int value = 20;public void printValues() {System.out.println("子类的值：" + value);       // 20System.out.println("父类的值：" + super.value); // 10}
}

3. 调用父类的方法

  • 语法：super.方法名([参数列表])
  • 作用：当子类重写了父类的方法时，可以使用super调用父类的原始方法。
  • 示例：

    java

    class Shape {public void draw() {System.out.println("绘制形状");}
}class Circle extends Shape {@Overridepublic void draw() {super.draw(); // 调用父类的方法System.out.println("绘制圆形");}
}

4. 注意事项

  • 构造方法调用：
    • 如果子类构造方法中没有显式调用super()，编译器会自动添加一个无参的super()。
    • 如果父类没有无参构造方法，子类必须显式调用父类的有参构造方法。
  • 静态成员：super不能用于静态方法，因为静态方法属于类，不存在继承关系。
  • 访问权限：super只能访问父类中public和protected修饰的成员。

5. 常见应用场景

  • 初始化父类状态：在子类构造方法中初始化父类的字段。
  • 扩展父类功能：在子类重写的方法中，先调用父类的方法，再添加额外功能。
  • 解决命名冲突：当子类与父类存在同名成员时，明确指定访问父类的成员。

总结

super关键字是 Java 中处理继承关系的重要工具，它使得子类能够灵活地访问和使用父类的成员，增强了代码的可维护性和扩展性。通过合理使用super，可以避免代码重复，构建更清晰的类层次结构。

6 抽象类的调用

抽象类必须通过子类继承并实现其所有抽象方法后才能使用。下面通过一个完整的例子帮你理解抽象类的用法：

步骤 1：定义抽象类

假设我们有一个抽象类 Shape，包含抽象方法 calculateArea() 和普通方法 display()：

java

// 抽象类：形状
public abstract class Shape {protected String color;// 构造方法public Shape(String color) {this.color = color;}// 抽象方法：计算面积（必须由子类实现）public abstract double calculateArea();// 普通方法：显示信息public void display() {System.out.println("颜色：" + color + "，面积：" + calculateArea());}
}

步骤 2：创建子类并实现抽象方法

创建具体子类（如 Circle 和 Rectangle），继承 Shape 并实现抽象方法：

java

// 子类：圆形
public class Circle extends Shape {private double radius;public Circle(String color, double radius) {super(color); // 调用父类构造方法this.radius = radius;}// 实现抽象方法：计算圆的面积@Overridepublic double calculateArea() {return Math.PI * radius * radius;}
}// 子类：矩形
public class Rectangle extends Shape {private double width;private double height;public Rectangle(String color, double width, double height) {super(color); // 调用父类构造方法this.width = width;this.height = height;}// 实现抽象方法：计算矩形的面积@Overridepublic double calculateArea() {return width * height;}
}

步骤 3：使用子类创建对象

通过子类实例化对象，并调用父类的方法（包括抽象方法的实现）：

java

public class Main {public static void main(String[] args) {// 错误：无法直接实例化抽象类// Shape shape = new Shape("红色"); // 正确：通过子类创建对象Shape circle = new Circle("红色", 5.0);Shape rectangle = new Rectangle("蓝色", 4.0, 6.0);// 调用父类的方法（自动使用子类的实现）circle.display();   // 输出：颜色：红色，面积：78.5398...rectangle.display(); // 输出：颜色：蓝色，面积：24.0}
}

关键概念总结：

  1. 抽象类不能直接实例化，必须通过子类创建对象。
  2. 子类必须实现抽象类的所有抽象方法，否则子类也会被视为抽象类。
  3. 通过父类引用指向子类对象（如 Shape circle = new Circle()），可以实现多态调用。
  4. 抽象方法的实现由子类完成，父类的普通方法可以直接被子类继承和调用。

常见问题：

  • Q：如果子类只实现了部分抽象方法会怎样？
    A： 子类必须被声明为 abstract，否则会编译错误。

  • Q：抽象类可以有构造方法吗？
    A： 可以，但构造方法只能被子类调用（通过 super()），不能直接创建对象。

  • Q：抽象类和接口的区别是什么？
    A： 抽象类可以包含普通方法和字段，而接口中的方法默认是抽象的（Java 8+ 支持默认方法）。

通过这种方式，抽象类可以作为 “模板”，强制子类实现特定行为，同时共享通用逻辑。

7 实现抽象方法都要重写吗?是的

在 Java 中，实现抽象方法和重写（Override）方法本质上是同一个操作。当子类继承抽象类时，必须重写（实现）抽象类中的所有抽象方法，否则子类也会被视为抽象类。

关键概念解释：

  1. 抽象方法：

    • 抽象方法是抽象类中没有方法体的方法，用 abstract 关键字声明，例如：

      java

      public abstract void calculateArea(); // 没有方法体

  2. 实现抽象方法：

    • 子类必须提供抽象方法的具体实现，这就是重写。例如：

      java

      @Override
public double calculateArea() {return Math.PI * radius * radius; // 具体实现
}

  3. @Override 注解：

    • 可选但推荐使用，用于告诉编译器这是一个重写方法。如果拼写错误或参数不匹配，编译器会报错。

示例代码：

java

// 抽象类
abstract class Animal {public abstract void sound(); // 抽象方法
}// 子类必须实现抽象方法
class Dog extends Animal {@Overridepublic void sound() {System.out.println("汪汪叫");}
}// 如果子类不实现抽象方法，则子类也必须声明为抽象类
abstract class Bird extends Animal {// 未实现 sound() 方法，Bird 必须是抽象类
}

为什么必须重写抽象方法？

  • 抽象类的设计目的是定义通用接口，子类必须完成具体实现。
  • 如果子类不重写所有抽象方法，它就无法成为一个完整的 “具体类”，因此编译器会强制要求子类继续声明为抽象类。

常见误区：

  • 重写 vs 重载：

    • 重写（Override）：子类重新实现父类的方法（方法签名必须相同）。
    • 重载（Overload）：在同一个类中定义多个同名但参数不同的方法。

  • 抽象方法只能在抽象类中声明，但抽象类中可以有普通方法（不需要子类重写）。

通过重写抽象方法，子类能够遵循抽象类定义的 “契约”，同时实现自己的独特逻辑。

相关文章：

  • 中大型水闸安全监测系统解决方案
  • AB Download Manager v1.5.8 开源免费下载工具
  • 日语学习-日语知识点小记-构建基础-JLPT-N4阶段（22）：复习
  • C/C++实践（八）C++ Sort函数详解，从基础到进阶
  • MySQL MCP 使用案例
  • Mybatis 嵌套子查询动态SQL编写
  • QT6 源（103）篇三：阅读与注释 QPlainTextEdit，给出源代码
  • Mysql、Oracle、Sql Server、达梦之间sql的差异
  • 搭建游戏云服务器的配置要求包括哪些条件？
  • HOW - React NextJS 的同构机制
  • WebRTC中的几个Channel
  • 【网络编程】十、详解 UDP 协议
  • Python教程(五)——模块
  • c/c++的opencv的图像预处理讲解
  • MapReduce Shuffle 全解析：从 Map 端到 Reduce 端的核心数据流​
  • Spring bean 的生命周期、注入方式和作用域
  • C41-为什么要用指针
  • ubuntu环境下 基于Python 打包的 批量命令行可视化操作工具 GUI
  • Vue3项目使用ElDrawer后select方法不生效
  • 分布式 ID 生成的五种方法：优缺点与适用场景
  • 武康大楼再开发：一栋楼火还不够，要带火街区“朋友圈”
  • 雅典卫城上空现“巨鞋”形状无人机群，希腊下令彻查
  • 外交部部长助理兼礼宾司司长洪磊接受美国新任驻华大使递交国书副本
  • 国家统计局公布2024年城镇单位就业人员年平均工资情况
  • 跨越三十年友情，61岁余隆和60岁齐默尔曼在上海再度合作
  • 乌克兰谈判代表团由12人组成，乌防长率领