当前位置:  首页>> 技术小册>> Java面试指南

Java是一种面向对象的编程语言,这意味着Java程序主要是由对象组成的。面向对象编程(OOP)中的核心概念包括类(class)、对象(object)、继承(inheritance)、封装(encapsulation)和多态(polymorphism)。以下是每个概念的简要描述以及示例代码:

类(class):
类是Java中的基本编程块,是创建对象的模板。类定义了对象的属性和行为。下面是一个简单的类定义:

  1. public class Person {
  2. private String name; //私有成员变量
  3. private int age;
  4. public Person(String name, int age) { //构造函数
  5. this.name = name;
  6. this.age = age;
  7. }
  8. public void display() { //方法
  9. System.out.println("Name: " + name + " Age: " + age);
  10. }
  11. }

对象(object):
对象是类的实例,它有自己的状态和行为。下面是创建Person对象的示例代码:

  1. Person person1 = new Person("John", 20); //创建对象
  2. person1.display(); //调用对象的方法

继承(inheritance):
继承是指一个类可以从另一个类继承属性和方法。这样可以减少代码重复并提高代码复用性。下面是一个继承的示例:

  1. public class Student extends Person { //继承自Person类
  2. private int grade;
  3. public Student(String name, int age, int grade) { //构造函数
  4. super(name, age); //调用父类构造函数
  5. this.grade = grade;
  6. }
  7. public void display() { //重写父类方法
  8. super.display(); //调用父类方法
  9. System.out.println("Grade: " + grade);
  10. }
  11. }

封装(encapsulation):
封装是指将数据和代码包装在一个单元中,以便于控制数据的访问。这样可以防止数据被意外地修改或破坏。下面是一个封装的示例:

  1. public class BankAccount {
  2. private double balance;
  3. public void deposit(double amount) { //存款方法
  4. balance += amount;
  5. }
  6. public void withdraw(double amount) { //取款方法
  7. if (amount <= balance) {
  8. balance -= amount;
  9. }
  10. }
  11. public double getBalance() { //获取余额方法
  12. return balance;
  13. }
  14. }

多态
Java中的多态是指同一个方法名可以被不同的对象使用,并且根据调用对象的不同,可以产生不同的行为。这种特性可以使程序更加灵活、易于维护和扩展。

在Java中,多态是通过继承和接口实现的。子类可以重写父类的方法,从而实现多态。同时,Java中的接口可以定义方法,实现接口的类必须实现这些方法,从而实现多态。以下是示例代码来说明多态的使用方法。

  1. // Animal.java
  2. public class Animal {
  3. public void makeSound() {
  4. System.out.println("The animal makes a sound");
  5. }
  6. }
  7. // Cat.java
  8. public class Cat extends Animal {
  9. public void makeSound() {
  10. System.out.println("Meow");
  11. }
  12. }
  13. // Dog.java
  14. public class Dog extends Animal {
  15. public void makeSound() {
  16. System.out.println("Woof");
  17. }
  18. }
  19. // Main.java
  20. public class Main {
  21. public static void main(String[] args) {
  22. Animal myPet;
  23. myPet = new Cat();
  24. myPet.makeSound(); // Meow
  25. myPet = new Dog();
  26. myPet.makeSound(); // Woof
  27. }
  28. }

在这个示例代码中,Animal是一个基类,Cat和Dog是Animal的子类。Cat和Dog都重写了Animal的makeSound方法。在Main中,我们创建了一个Animal类型的对象myPet,首先让它指向一个Cat对象,然后调用makeSound方法,输出”Meow”。然后让它指向一个Dog对象,再次调用makeSound方法,输出”Woof”。因为myPet变量的类型是Animal,但是指向的对象是Cat或Dog,所以程序根据对象的类型来调用相应的makeSound方法,实现了多态。