java面向对象程序设计知识点总结

原创于 2025-05-09 15:52:07 发布

· 894 阅读

11 ·

版权

文章标签：

#java #开发语言

一、面向对象的基本概念

1. 类和对象

类：是对象的蓝图或模板，定义了对象的属性和行为。

对象：是类的实例，通过类创建的具体实体。

代码实现：

public class Person {

String name;

int age;

public Person(String name, int age) {

this.name = name; this.age = age; }

public void introduce() {

System.out.println("Hi, I'm " + name + " and I'm " + age + " years old."); } }

public class Main { public static void main(String[] args) {

Person person = new Person("Alice", 30); person.introduce();

Hi, I'm Alice and I'm 30 years old. } }

2. 封装

封装是指将对象的属性和行为捆绑在一起，并对外界隐藏内部实现细节。通过访问修饰符控制访问权限。

代码实现：

public class BankAccount {

private String accountNumber;

private double balance;

public BankAccount(String accountNumber, double initialBalance) {

this.accountNumber = accountNumber; this.balance = initialBalance; }

public void deposit(double amount) {

if(amount > 0){ balance += amount; System.out.println("Deposited: " + amount); } }

public void withdraw(double amount) {

if(amount > 0 && balance >= amount){

balance -= amount; System.out.println("Withdrew: " + amount); }

else { System.out.println("Insufficient funds or invalid amount."); } }

public double getBalance() { return balance; } }

public class Main {

public static void main(String[] args) {

BankAccount account = new BankAccount("123456789", 1000);

account.deposit(500); account.withdraw(200);

System.out.println("Current Balance: " + account.getBalance()); } }

3. 继承

继承允许一个类（子类）继承另一个类（父类）的属性和方法，实现代码复用和多态性。

代码实现：

public class Animal {

String name; public void eat() {

System.out.println(name + " is eating."); } }

public class Dog extends Animal {

public void bark() { System.out.println(name + " is barking."); } }

public class Main {

public static void main(String[] args) {

Dog dog = new Dog(); dog.name = "Buddy"; dog.eat();

Buddy is eating. dog.bark();

Buddy is barking. } }

4. 多态

多态是指同一个方法在不同对象上表现出不同的行为。主要通过方法重载（Overloading）和方法重写实现。

代码实现：

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

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

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

public class Main { public static void main(String[] args) { Animal myDog = new Dog(); Animal myCat = new Cat(); myDog.makeSound();

Woof myCat.makeSound();

Meow } }

5. 抽象类和接口

抽象类：不能被实例化的类，包含抽象方法（没有方法体）和具体方法。用于定义共性。

接口：一种抽象类型，包含抽象方法和常量。用于定义行为规范。

代码实现：

public abstract class Shape { public abstract double getArea(); public abstract double getPerimeter(); public void display() { System.out.println("Displaying shape."); } }

public class Circle extends Shape { 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 interface Drivable { void drive(); void brake(); }

public class Car implements Drivable { @Override public void drive() { System.out.println("Car is driving."); } @Override public void brake() { System.out.println("Car is braking."); } }

public class Main { public static void main(String[] args) { Shape circle = new Circle(5); System.out.println("Area: " + circle.getArea()); circle.display(); Drivable myCar = new Car(); myCar.drive(); myCar.brake(); } }

二、面向对象的高级概念

1. 构造方法

构造方法是用于创建对象时初始化对象的一种特殊方法。可以重载构造方法以提供不同的初始化方式。

代码实现：

public class Person { String name; int age;

public Person() { this.name = "Unknown"; this.age = 0; }

public Person(String name, int age) { this.name = name; this.age = age; } }

2. 静态成员

静态成员属于类本身，而不是某个具体的对象。包括静态变量和静态方法。

public class MathUtils {

public static final double PI = 3.14159;

public static int add(int a, int b) { return a + b; } }

public class Main { public static void main(String[] args) { System.out.println("Value of PI: " + MathUtils.PI); int sum = MathUtils.add(5, 3); System.out.println("Sum: " + sum); } }

3. 内部类

内部类是在一个类的内部定义的类，可以访问外部类的私有成员。

public class OuterClass { private String message = "Hello from OuterClass";

public class InnerClass { public void showMessage() { System.out.println(message); } }

public void createInner() { InnerClass inner = new InnerClass(); inner.showMessage(); } }

public class Main { public static void main(String[] args) { OuterClass outer = new OuterClass(); outer.createInner();

Hello from OuterClass OuterClass.InnerClass inner = outer.new InnerClass(); inner.showMessage(); } }

4. 匿名类

匿名类是没有名称的内部类，通常用于简化代码。

public interface Greeting { void greet(); }

public class Main { public static void main(String[] args) { Greeting greeting = new Greeting() { @Override public void greet() { System.out.println("Hello, Anonymous!"); } }; greeting.greet();Hello, Anonymous! } }