学习日志08 java

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

    @Override
    public 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);       // 20
          System.out.println("父类的值：" + super.value); // 10
      }
  }
  

3. 调用父类的方法

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

  java

  class Shape {
      public void draw() {
          System.out.println("绘制形状");
      }
  }
  
  class Circle extends Shape {
      @Override
      public 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;
    }

    // 实现抽象方法：计算圆的面积
    @Override
    public 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;
    }

    // 实现抽象方法：计算矩形的面积
    @Override
    public 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 {
    @Override
    public void sound() {
        System.out.println("汪汪叫");
    }
}

// 如果子类不实现抽象方法，则子类也必须声明为抽象类
abstract class Bird extends Animal {
    // 未实现 sound() 方法，Bird 必须是抽象类
}

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

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

常见误区：

• 重写 vs 重载：

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

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

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