Java学习教程，从入门到精通，Java对象和类语法知识点（20）

1、Java对象和类语法知识点

1. 类的定义

   • 使用class关键字定义类。
   • 类名通常使用大写驼峰命名法（PascalCase）。
   • 类与对象
     • 类是创建对象的模板或蓝图，它定义了对象的属性和行为。
     • 对象是类的实例，它包含了类定义的数据（属性）和行为（方法）。

2. 成员变量

   • 类中定义的变量称为成员变量或属性。
   • 可以使用访问修饰符（如private, public, protected）控制访问权限。

3. 构造方法

   • 与类名相同且没有返回类型的方法称为构造方法。
   • 用于在创建对象时初始化对象的状态。

4. 方法

   • 类中定义的函数称为方法。
   • 方法可以包含参数和返回类型。

5. 对象的创建

   • 使用new关键字和类的构造方法创建对象。
   • 对象是对类的一个实例。

6. 访问对象的成员

   • 使用.运算符访问对象的成员变量和方法。

7. 封装

   • 使用private关键字隐藏类的属性。
   • 提供public的getter和setter方法访问属性。

8. 继承

   • 使用extends关键字让一个类继承另一个类。
   • 子类可以访问父类的public和protected成员。

9. 多态

   • 允许一个引用变量在不同情况下指向不同类型的对象。
   • 通过方法重写（使用@Override注解）实现。

10. 抽象类和接口

    • 抽象类不能被实例化，可以包含抽象方法和具体方法。
    • 接口是完全抽象的类，只能包含抽象方法（从Java 8开始，接口也可以有默认方法和静态方法）。

案例代码

以下是一个简单的Java程序，演示了上述知识点：

// 定义一个抽象类
abstract class Animal {
    // 抽象方法
    public abstract void makeSound();

    // 具体方法
    public void move() {
        System.out.println("The animal moves.");
    }
}

// 定义一个接口
interface Swimmer {
    void swim();
}

// 定义一个具体类，继承抽象类并实现接口
class Dog extends Animal implements Swimmer {
    // 成员变量
    private String name;
    private int age;

    // 构造方法
    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 重写抽象类中的抽象方法
    @Override
    public void makeSound() {
        System.out.println("The dog barks.");
    }

    // 实现接口中的方法
    @Override
    public void swim() {
        System.out.println("The dog is swimming.");
    }

    // 自定义方法
    public void displayInfo() {
        System.out.println("Dog name: " + name + ", Age: " + age);
    }

    // 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) {
        this.age = age;
    }
}
public class Main {
    public static void main(String[] args) {
        // 创建Dog对象
        Dog myDog = new Dog("Buddy", 5);

        // 访问成员变量和方法
        myDog.displayInfo();
        myDog.makeSound();
        myDog.move();
        myDog.swim();
        // 使用setter方法修改成员变量
        myDog.setAge(6);

        // 使用getter方法获取成员变量
        System.out.println("Dog's new age: " + myDog.getAge());
    }
}

解释

1. 抽象类Animal：定义了一个抽象方法makeSound()和一个具体方法move()。
2. 接口Swimmer：定义了一个抽象方法swim()。
3. 具体类Dog：
   • 继承Animal类，因此必须实现makeSound()方法。
   • 实现Swimmer接口，因此必须实现swim()方法。
   • 定义了成员变量name和age，以及相应的构造方法、getter和setter方法。
   • 定义了一个自定义方法displayInfo()来显示狗的信息。
4. Main类：包含main方法，用于创建Dog对象并调用其方法。

通过这个程序，你可以看到如何定义类、创建对象、访问成员变量和方法、实现继承和多态、以及使用抽象类和接口。

当然可以，以下是一些具体的Java对象和类的案例代码，涵盖了不同的应用场景：

案例一：地址类（Address）

这个案例定义了一个Address类，用于表示地址信息，包括国家、省份、城市、街道和邮编。

class Address {
    private String country;
    private String province;
    private String city;
    private String street;
    private String zipcode;
    // 默认构造方法
    public Address() {}

    // 带参数的构造方法
    public Address(String country, String province, String city, String street, String zipcode) {
        this.country = country;
        this.province = province;
        this.city = city;
        this.street = street;
        this.zipcode = zipcode;
    }

    // 获取完整地址信息的方法
    public String getInfo() {
        return "国家:" + this.country + "、省份:" + this.province + "、城市:" + this.city + "、街道:" + this.street + "、邮编:" + this.zipcode;
    }

    // Getter和Setter方法（省略）
}

public class AddressDemo {
    public static void main(String[] args) {
        Address address = new Address("中国", "北京市", "海淀区", "中关村大街", "100080");
        System.out.println(address.getInfo());
    }
}

案例二：员工类（Employee）

这个案例定义了一个Employee类，用于表示员工信息，包括编号、姓名、基本薪水和薪水增长率。

class Employee {
    private long empno;
    private String empname;
    private double salary;
    private double rate;

    // 默认构造方法
    public Employee() {}

    // 带参数的构造方法
    public Employee(long empno, String empname, double salary, double rate) {
        this.empno = empno;
        this.empname = empname;
        this.salary = salary;
        this.rate = rate;
    }

    // 计算薪水增长额的方法
    public double salaryIncValue() {
        return this.salary * this.rate;
    }

    // 计算工资总额的方法
    public double salaryIncResult() {
        this.salary = this.salary * (1 + this.rate);
        return this.salary;
    }

    // 获取员工信息的方法
    public String getInfo() {
        return "员工编号:" + this.empno + "、员工姓名:" + this.empname + "、基本工资:" + this.salary + "、工资增长率:" + this.rate;
    }

    // Getter和Setter方法（省略）
}

public class EmployeeDemo {
    public static void main(String[] args) {
        Employee employee = new Employee(9527L, "张三", 8000.0, 0.1);
        System.out.println(employee.getInfo());
        System.out.println("工资增长额度:" + employee.salaryIncValue());
        System.out.println("上调后工资额度:" + employee.salaryIncResult());
    }
}

案例三：抽象类和接口的应用

这个案例展示了如何使用抽象类和接口来设计更灵活的类结构。

// 定义一个抽象类
abstract class Shape {
    // 抽象方法
    public abstract double area();
}

// 定义一个接口
interface Drawable {
    void draw();
}

// 具体类，继承抽象类并实现接口
class Circle extends Shape implements Drawable {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    // 实现抽象类中的抽象方法
    @Override
    public double area() {
        return Math.PI * radius * radius;
    }

    // 实现接口中的方法
    @Override
    public void draw() {
        System.out.println("Drawing a circle with radius " + radius);
    }
}

public class ShapeDemo {
    public static void main(String[] args) {
        Circle circle = new Circle(5.0);
        System.out.println("Area of the circle: " + circle.area());
        circle.draw();
    }
}

案例四：多态性的应用

这个案例展示了Java中的多态性，即同一个引用类型可以指向不同类型的对象。

class Animal {
    void makeSound() {
        System.out.println("Some generic animal sound");
    }
}

class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Bark");
    }
}

class Cat extends Animal {
    @Override
    void makeSound() {
        System.out.println("Meow");
    }
}

public class PolymorphismDemo {
    public static void main(String[] args) {
        Animal myDog = new Dog(); // 多态：Animal类型的引用指向Dog对象
        Animal myCat = new Cat(); // 多态：Animal类型的引用指向Cat对象

        myDog.makeSound(); // 输出：Bark
        myCat.makeSound(); // 输出：Meow
    }
}

这些案例涵盖了Java中类和对象的基本用法，包括类的定义、构造方法、方法、封装、继承、多态、抽象类和接口等关键概念。通过这些案例，你可以更好地理解Java面向对象编程的精髓。