温馨提示:这篇文章已超过282天没有更新,请注意相关的内容是否还可用!
封装、继承、多态和抽象是Java面向对象编程的四个重要概念。
封装是指将数据和方法封装在一个类中,通过访问修饰符来控制对数据和方法的访问权限。封装可以隐藏类的内部实现细节,提供对外部的简洁接口,增加代码的安全性和可维护性。
示例代码如下:
public class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
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 void sayHello() {
System.out.println("Hello, my name is " + name);
}
}
public class Main {
public static void main(String[] args) {
Person person = new Person("John", 25);
System.out.println(person.getName()); // 输出:John
person.sayHello(); // 输出:Hello, my name is John
person.setName("Mike");
person.sayHello(); // 输出:Hello, my name is Mike
}
}
继承是指一个类可以继承另一个类的属性和方法,通过继承可以实现代码的重用和扩展。子类可以继承父类的非私有字段和方法,并可以重写父类的方法。
示例代码如下:
public class Student extends Person {
private String major;
public Student(String name, int age, String major) {
super(name, age);
this.major = major;
}
public String getMajor() {
return major;
}
public void setMajor(String major) {
this.major = major;
}
@Override
public void sayHello() {
System.out.println("Hello, my name is " + getName() + ", and I'm a student majoring in " + major);
}
}
public class Main {
public static void main(String[] args) {
Student student = new Student("Tom", 20, "Computer Science");
System.out.println(student.getName()); // 输出:Tom
student.sayHello(); // 输出:Hello, my name is Tom, and I'm a student majoring in Computer Science
student.setMajor("Mathematics");
student.sayHello(); // 输出:Hello, my name is Tom, and I'm a student majoring in Mathematics
}
}
多态是指同一类型的对象在不同情况下表现出不同的行为。通过多态,可以实现基于父类的统一接口,对不同子类对象进行统一处理。
示例代码如下:
public class Animal {
public void makeSound() {
System.out.println("The animal makes a sound");
}
}
public class Dog extends Animal {
@Override
public void makeSound() {
System.out.println("The dog barks");
}
}
public class Cat extends Animal {
@Override
public void makeSound() {
System.out.println("The cat meows");
}
}
public class Main {
public static void main(String[] args) {
Animal animal1 = new Dog();
Animal animal2 = new Cat();
animal1.makeSound(); // 输出:The dog barks
animal2.makeSound(); // 输出:The cat meows
}
}
抽象是指将类的共同特征提取出来形成抽象类或接口,用于定义一组规范,子类可以根据需要进行实现或继承。
示例代码如下:
public abstract class Shape {
public abstract double getArea();
public abstract double getPerimeter();
}
public class Circle extends Shape {
private double radius;
public Circle(double radius) {
this.radius = radius;
}
@Override
public double getArea() {
return Math.PI * radius * radius;
}
@Override
public double getPerimeter() {
return 2 * Math.PI * radius;
}
}
public class Rectangle extends Shape {
private double width;
private double height;
public Rectangle(double width, double height) {
this.width = width;
this.height = height;
}
@Override
public double getArea() {
return width * height;
}
@Override
public double getPerimeter() {
return 2 * (width + height);
}
}
public class Main {
public static void main(String[] args) {
Shape circle = new Circle(5);
Shape rectangle = new Rectangle(3, 4);
System.out.println(circle.getArea()); // 输出:78.53981633974483
System.out.println(circle.getPerimeter()); // 输出:31.41592653589793
System.out.println(rectangle.getArea()); // 输出:12.0
System.out.println(rectangle.getPerimeter()); // 输出:14.0
}
}