Java学习第三部分——面向对象基础

目录

一.简介 

二.类和对象

（一）类（Class）         

（二）对象（Object）     

三.构造方法（Constructor）       

四.封装（Encapsulation） 

五.继承（Inheritance） 

六.多态（Polymorphism）   

（一）方法重载（Method Overloading）

（二）方法覆盖（Method Overriding）

七.抽象类和接口

（一）抽象类（Abstract Class）

（二）接口（Interface）

八.内部类和匿名类

 （一）内部类（Inner Class）

（二）匿名类（Anonymous Class）

九.示例代码

---

一.简介 

       面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，它通过“对象”来模拟现实世界中的事物和事物之间的关系。Java 是一种典型的面向对象编程语言，它提供了类、对象、继承、封装、多态等核心概念来支持面向对象编程。

二.类和对象

（一）类（Class）
         

       类是对象的模板，用于定义具有相同属性和行为的一组对象。类中包含属性（变量）和方法（函数）。

示例：
public class Student {
    // 属性
    String name;
    int age;

    // 方法
    public void study() {
        System.out.println(name + "正在学习");
    }

    public void displayInfo() {
        System.out.println("姓名：" + name + "，年龄：" + age);
    }
}

（二）对象（Object）
     

       对象是类的实例，通过 `new` 关键字创建。

示例：
public class Main {
    public static void main(String[] args) {
        // 创建对象
        Student student1 = new Student();
        student1.name = "张三";
        student1.age = 20;

        // 调用方法
        student1.study();
        student1.displayInfo();
    }
}
 

三.构造方法（Constructor）
       

       构造方法用于创建对象时初始化对象的属性。构造方法的名称必须与类名相同，且没有返回值类型。

示例：
public class Student {
    String name;
    int age;

    // 无参构造方法
    public Student() {
        System.out.println("无参构造方法被调用");
    }

    // 有参构造方法
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("有参构造方法被调用");
    }

    public void study() {
        System.out.println(name + "正在学习");
    }
}
 

使用构造方法创建对象：
public class Main {
    public static void main(String[] args) {
        // 使用无参构造方法创建对象
        Student student1 = new Student();
        student1.name = "张三";
        student1.age = 20;
        student1.study();

        // 使用有参构造方法创建对象
        Student student2 = new Student("李四", 22);
        student2.study();
    }
}
 

四.封装（Encapsulation） 

       封装是面向对象的一个重要特性，它将对象的属性和行为封装在一起，隐藏对象的内部实现细节，只暴露必要的接口。

示例：
public class BankAccount {
    private double balance; // 私有属性

    // 提供公共方法来访问和修改余额
    public void deposit(double amount) {
        balance += amount;
    }

    public void withdraw(double amount) {
        if (amount <= balance) {
            balance -= amount;
        } else {
            System.out.println("余额不足");
        }
    }

    public double getBalance() {
        return balance;
    }
}

使用封装的类：
public class Main {
    public static void main(String[] args) {
        BankAccount account = new BankAccount();
        account.deposit(1000);
        account.withdraw(500);
        System.out.println("当前余额：" + account.getBalance());
    }
}

五.继承（Inheritance）
 

       继承允许一个类继承另一个类的属性和方法。使用 `extends` 关键字来实现继承。

示例：
public class Animal {
    public void eat() {
        System.out.println("动物吃东西");
    }
}

public class Dog extends Animal {
    public void bark() {
        System.out.println("狗叫");
    }
}

使用继承：
public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat(); // 继承自 Animal 类的方法
        dog.bark(); // Dog 类自己的方法
    }
}

六.多态（Polymorphism）
   

       多态是指允许不同类的对象对同一消息做出响应，即同一个接口使用不同的底层实现。多态分为编译时多态（方法重载）和运行时多态（方法覆盖）。

（一）方法重载（Method Overloading）

       同一个类中，方法名相同，参数列表不同（参数类型、参数个数或两者都不同）。

示例：
public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }

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

（二）方法覆盖（Method Overriding）

       子类重写父类的方法。

示例：
public class Animal {
    public void eat() {
        System.out.println("动物吃东西");
    }
}

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}

使用多态：
public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.eat(); // 输出 "狗吃骨头"，运行时多态
    }
}

七.抽象类和接口

（一）抽象类（Abstract Class）

       抽象类是不能被实例化的类，它通常包含抽象方法（没有实现体的方法）。

示例：
public abstract class Animal {
    public abstract void eat(); // 抽象方法
}

（二）接口（Interface）

       接口是一种特殊的抽象类，它只能包含抽象方法和常量。从 Java 8 开始，接口也可以包含默认方法和静态方法。

示例：
public interface Animal {
    void eat(); // 抽象方法

    default void sleep() {
        System.out.println("动物睡觉");
    }
}
实现接口：
public class Dog implements Animal {
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}
使用接口：
public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.eat(); // 输出 "狗吃骨头"
        animal.sleep(); // 输出 "动物睡觉"
    }
}

八.内部类和匿名类

 （一）内部类（Inner Class）

       内部类是定义在另一个类内部的类。

示例：
public class OuterClass {
    private int outerData = 10;

    public class InnerClass {
        public void display() {
            System.out.println("外部类的数据：" + outerData);
        }
    }
}

使用内部类：
public class Main {
    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        OuterClass.InnerClass inner = outer.new InnerClass();
        inner.display(); // 输出 "外部类的数据：10"
    }
}

（二）匿名类（Anonymous Class）

       匿名类是没有名字的内部类，通常用于创建单次使用的对象。

示例：
public interface Animal {
    void eat();
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Animal() {
            @Override
            public void eat() {
                System.out.println("匿名类中的动物吃东西");
            }
        };
        animal.eat(); // 输出 "匿名类中的动物吃东西"
    }
}
 

九.示例代码

// 定义一个抽象类
abstract class Animal {
    public abstract void eat();
}

// 定义一个接口
interface Movable {
    void move();
}

// 定义一个具体类，继承抽象类并实现接口
class Dog extends Animal implements Movable {
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    @Override
    public void move() {
        System.out.println("狗跑");
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建对象
        Dog dog = new Dog();
        dog.eat(); // 输出 "狗吃骨头"
        dog.move(); // 输出 "狗跑"
    }
}