Java中类与对象的相关知识点总结

下面是关于“Java中类与对象的相关知识点总结”的详细攻略。

什么是Java中类与对象

Java是一种基于对象的编程语言，类是Java中的基本概念。类是Java中定义对象的模板，由属性和方法组成。而对象则是类的实例，具有类中定义的属性和方法。利用类和对象，我们可以很方便地组织代码、实现代码的复用和扩展。

如何定义类

定义类的格式如下：

[public] class ClassName [extends ParentClassName] {
    // 类变量
    // 构造函数
    // 方法
}

我们通常需要在定义类时：

• 使用public关键字来让类在其他包中也可以被访问。
• 使用extends关键字来继承其他类。
• 在类中定义属性，可以是实例变量或静态变量，用来描述对象的特征。
• 在类中定义构造函数，用来初始化对象。
• 在类中定义方法，包括实例方法和静态方法，用来操作类的属性和完成类的功能。

下面是一个简单的例子，定义了一个名为Person的类：

public class Person {
    // 实例变量
    String name;
    int age;

    // 构造函数
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 方法
    public void sayHello() {
        System.out.println("Hello, my name is " + name + ", I am " + age + " years old.");
    }
}

如何创建对象

要创建一个对象，我们需要使用new关键字来调用类的构造函数。语法如下：

ClassName objectName = new ClassName([arguments]);

下面是一个例子，创建了一个名字为张三，年龄为18的Person对象：

Person p = new Person("张三", 18);

如何访问对象的属性和方法

通过对象名加点号来访问对象的属性和方法，语法如下：

objectName.propertyName;
objectName.methodName([arguments]);

下面是一个例子，访问了刚才创建的Person对象的name属性和sayHello方法：

System.out.println(p.name); // 输出张三
p.sayHello(); // 输出Hello, my name is 张三, I am 18 years old.

封装

封装是面向对象编程中的一个重要概念，它将对象的属性隐藏起来，只提供公共的方法来访问对象的属性。这样可以保证数据的安全性和稳定性，避免因外部访问而导致的不可预料的结果。在Java中封装可以通过访问修饰符来实现：

• private：私有的，只有在类内部才能访问。
• default：默认的，只有在同一包中才能访问。
• protected：受保护的，可以被继承的子类访问。
• public：公共的，可以被任何地方访问。

下面是一个例子，将Person类中的name属性封装为私有的：

public class Person {
    // 私有实例变量
    private String name;
    int age;

    // 构造函数
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 公共方法
    public void setName(String name) {
        this.name = name;
    }

    public void sayHello() {
        System.out.println("Hello, my name is " + name + ", I am " + age + " years old.");
    }
}

在上面的例子中，将name属性封装为了私有的，但是提供了公共的setName方法来修改name属性的值。

继承

继承是面向对象编程中的另一个重要概念，它允许我们创建一个新的类，并通过沿用现有类的所有属性和方法来扩展它。在Java中，使用extends关键字来继承一个类，子类可以获取到父类的public和protected属性和方法，但无法获取到private属性和方法。

下面是一个例子，定义了一个Student类来继承Person类：

public class Student extends Person {
    // 新增实例变量
    int grade;

    // 新增构造函数
    public Student(String name, int age, int grade) {
        super(name, age);
        this.grade = grade;
    }

    // 新增方法
    public void study() {
        System.out.println(name + " is studying in grade " + grade);
    }
}

在上面的例子中，使用了super关键字来调用父类的构造函数，以初始化父类中的属性，还新增了一个study方法。

多态

多态是面向对象编程中的另一个重要概念，它允许我们在不同的对象之间使用相同的代码。在Java中，多态可以通过类继承和方法重写来实现。具体来说，子类可以继承父类的方法，但可以根据自己的需要重新定义父类方法的行为，这就是方法重写。

下面是一个例子，定义了一个名为talk的方法，来展示多态的实现：

public class Talkable {
    public void talk() {
        System.out.println("I'm talking");
    }
}

public class Person extends Talkable {
    public void talk() {
        System.out.println("I'm a person, I'm talking");
    }
}

public class Student extends Person {
    public void talk() {
        System.out.println("I'm a student, I'm talking");
    }
}

public class Test {
    public static void main(String[] args) {
        Talkable t1 = new Talkable();
        Talkable t2 = new Person();
        Talkable t3 = new Student();

        t1.talk(); // 输出 I'm talking
        t2.talk(); // 输出 I'm a person, I'm talking
        t3.talk(); // 输出 I'm a student, I'm talking
    }
}

在上面的例子中，Talkable类中定义了talk方法，在Person和Student类中重写talk方法，可以看到对于不同的对象，talk方法的输出结果也不同。

示例如下

1、定义一个名为Shape的抽象类，用来描述形状，包括面积计算和输出形状的方法，并定义两个实现类Circle和Rectangle，分别实现Shape类中定义的面积计算方法和输出形状方法。

public abstract class Shape {
    public abstract double getArea();

    public abstract void draw();
}

public class Circle extends Shape {
    private double radius;

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

    public double getArea() {
        return Math.PI * radius * radius;
    }

    public void draw() {
        System.out.println("Drawing a circle...");
    }
}

public class Rectangle extends Shape {
    private double width;
    private double height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    public double getArea() {
        return width * height;
    }

    public void draw() {
        System.out.println("Drawing a rectangle...");
    }
}

2、定义一个名为Bicycle的类，用来描述自行车，包括品牌、颜色、价格等属性，以及骑行和刹车两个方法，还定义一个继承自Bicycle的MountainBike类，用来描述山地自行车，新增了挡泥板和悬挂的属性和相关方法。

public class Bicycle {
    protected String brand;
    protected String color;
    protected int price;

    public Bicycle(String brand, String color, int price) {
        this.brand = brand;
        this.color = color;
        this.price = price;
    }

    public void ride() {
        System.out.println("Riding the bicycle...");
    }

    public void brake() {
        System.out.println("Braking the bicycle...");
    }
}

public class MountainBike extends Bicycle {
    private boolean fender;
    private boolean suspension;

    public MountainBike(String brand, String color, int price, boolean fender, boolean suspension) {
        super(brand, color, price);
        this.fender = fender;
        this.suspension = suspension;
    }

    public boolean hasFender() {
        return fender;
    }

    public boolean hasSuspension() {
        return suspension;
    }

    public void installFender() {
        System.out.println("Installing the fender...");
    }

    public void installSuspension() {
        System.out.println("Installing the suspension...");
    }
}