Java基础：面向对象编程(1)

于 2024-10-10 09:59:34 发布
阅读量349 收藏 14
点赞数 9
分类专栏： Java 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gaosw0521/article/details/142811942
版权

1 Java中的类和对象

1.1 面向过程和面向对象

面向过程是流程化的，一步一步，上一步做完了，再做下一步。

面向对象是模块化的，我做我的，你做你的，我需要你做的话，我就告诉你一声。我不需要知道你到底怎么做，只看功劳不看苦劳。

不过，如果追到底的话，面向对象的底层其实还是面向过程，只不过把面向过程进行了抽象化，封装成了类，方便我们的调用。

1.2 类

1.2.1 类（Class）

  • 定义：类是对象的蓝图或模板，定义了对象的属性和行为。
  • 示例：Person 类定义了一个人的基本属性和行为。

1.2.2 字段（Field）

  • 定义：字段是类的成员变量，用于存储对象的状态。
  • 示例：Person 类中的 name、age 和 sex 是字段，分别表示人的姓名、年龄和性别。
  • 实例变量：字段也称为实例变量，因为它们在对象实例化后才会分配内存。

1.2.3 方法（Method）

  • 定义：方法是类的行为，定义了对象可以执行的操作。
  • 示例：Person 类中的 eat()、sleep() 和 dadoudou() 是方法，分别表示人可以吃饭、睡觉和打豆豆。

1.2.4 构造方法（Constructor）

  • 定义：构造方法是用于创建和初始化对象的特殊方法。
  • 示例：Person 类中的 public Person() {} 是默认的构造方法。
  • 默认构造方法：如果类中没有显式定义构造方法，Java 会自动提供一个默认的无参构造方法。

1.2.5 代码示例

public class Person {
    private String name;
    private int age;
    private int sex;

    // 默认构造方法
    public Person() {
    }

    // 自定义构造方法
    public Person(String name, int age, int sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    private void eat() {
        System.out.println(name + " is eating.");
    }

    private void sleep() {
        System.out.println(name + " is sleeping.");
    }

    private void dadoudou() {
        System.out.println(name + " is dadoudou.");
    }
}

1.2.6 关键点总结

  1. 类：定义对象的蓝图。
  2. 字段：存储对象的状态，也称为实例变量。
  3. 方法：定义对象的行为。
  4. 构造方法：用于创建和初始化对象，如果没有显式定义，Java 会提供默认的无参构造方法。

1.2.7 进一步理解

  • 封装：通过将字段设为 private，并提供 public 的 getter 和 setter 方法，可以实现数据的封装，隐藏内部实现细节。
  • 继承：子类可以继承父类的字段和方法，并可以添加新的字段和方法。
  • 多态：同一个方法可以在不同的对象中有不同的实现，增加了代码的灵活性和可扩展性。

1.3 new一个对象

1.3.1 创建 Java 对象

  • 使用 new 关键字：在 Java 中，通过 new 关键字来创建对象。例如：
    Person person = new Person();
    这行代码通过 Person 类创建了一个 Person 对象，并在堆内存中为其分配空间。

1.3.2 main() 方法

  • 入口方法：main() 方法是 Java 程序的入口点，程序从这里开始执行。
  • 位置：main() 方法可以放在当前类中，也可以放在另一个类中。

1.3.3 示例代码

1.3.3.1 第一种：main() 方法在 Person 类中
public class Person {
    private String name;
    private int age;
    private int sex;

    private void eat() {}
    private void sleep() {}
    private void dadoudou() {}

    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name); // 输出: null
        System.out.println(person.age);  // 输出: 0
        System.out.println(person.sex);  // 输出: 0
    }
}
  • 输出结果：
    null
0
0
    这是因为 name 是 String 类型，默认值为 null，而 age 和 sex 是 int 类型，默认值为 0。
1.3.3.2 第二种：main() 方法在另一个类中
/**
 * @author 微信搜「沉默王二」，回复关键字 PDF
 */
public class PersonTest {
    public static void main(String[] args) {
        Person person = new Person();
    }
}

class Person {
    private String name;
    private int age;
    private int sex;

    private void eat() {}
    private void sleep() {}
    private void dadoudou() {}
}
  • 实际开发中：通常会将 main() 方法放在一个单独的测试类中，而不是直接放在要测试的类中。这样可以保持类的单一职责，便于维护和测试。

1.3.4 关键点总结

  1. 创建对象：使用 new 关键字创建对象，并在堆内存中分配空间。
  2. main() 方法：作为程序的入口点，可以放在当前类或另一个类中。
  3. 实际开发：通常将 main() 方法放在一个单独的测试类中，便于管理和维护。

1.3.5 进一步理解

  • 堆内存：对象在创建时会在堆内存中分配空间，堆内存是动态分配的，用于存储对象实例。
  • 栈内存：方法调用和局部变量存储在栈内存中，栈内存是线程私有的，用于存储方法调用和局部变量。
  • 默认值：类中的字段如果没有显式初始化，会有默认值。例如，int 类型的默认值是 0，String 类型的默认值是 null。

1.4 初始化对象

1.4.1 对象初始化的三种方法

1.4.1.1 第一种：通过对象的引用变量
public class Person {
    private String name;
    private int age;
    private int sex;

    public static void main(String[] args) {
        Person person = new Person();
        person.name = "沉默王二";
        person.age = 18;
        person.sex = 1;
        
        System.out.println(person.name); // 输出: 沉默王二
        System.out.println(person.age);  // 输出: 18
        System.out.println(person.sex);  // 输出: 1
    }
}
  • 直接赋值：通过对象的引用变量 person 直接对字段进行赋值。
  • 优点：简单直观。
  • 缺点：字段需要是 public 或 protected，破坏了封装性。
1.4.1.2 第二种：通过方法初始化
public class Person {
    private String name;
    private int age;
    private int sex;

    public void initialize(String n, int a, int s) {
        name = n;
        age = a;
        sex = s;
    }

    public static void main(String[] args) {
        Person person = new Person();
        person.initialize("沉默王二", 18, 1);

        System.out.println(person.name); // 输出: 沉默王二
        System.out.println(person.age);  // 输出: 18
        System.out.println(person.sex);  // 输出: 1
    }
}
  • 方法初始化：通过定义一个 initialize 方法来初始化字段。
  • 优点：保持了字段的封装性，字段可以是 private。
  • 缺点：需要调用方法进行初始化，稍微复杂一些。
1.4.1.3 第三种：通过构造方法初始化
public class Person {
    private String name;
    private int age;
    private int sex;

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

    public static void main(String[] args) {
        Person person = new Person("沉默王二", 18, 1);

        System.out.println(person.name); // 输出: 沉默王二
        System.out.println(person.age);  // 输出: 18
        System.out.println(person.sex);  // 输出: 1
    }
}
  • 构造方法初始化：在创建对象时通过构造方法传参进行初始化。
  • 优点：最标准和推荐的做法，保持了封装性，且在对象创建时完成初始化。
  • 缺点：需要定义构造方法，但通常这是最佳实践。

1.4.2 匿名对象

  • 定义：匿名对象是没有引用变量的对象，只能在创建时使用一次。
  • 示例：
    new Person().initialize("沉默王二", 18, 1);
  • 使用场景：适用于只需要使用一次的对象，不需要保存引用。

1.4.3 关键点总结

  1. 直接赋值：通过对象的引用变量直接对字段赋值，简单但破坏封装性。
  2. 方法初始化：通过定义方法来初始化字段，保持封装性，稍微复杂。
  3. 构造方法初始化：通过构造方法传参进行初始化，最标准和推荐的做法。
  4. 匿名对象：没有引用变量的对象，只能在创建时使用一次。

1.4.4 进一步理解

  • 封装性：通过方法和构造方法初始化字段，可以保持字段的封装性，避免外部直接访问和修改字段。
  • 构造方法重载：可以定义多个构造方法，提供不同的初始化方式，增加灵活性。
  • 默认值：未初始化的字段会有默认值，例如 String 类型的默认值是 null，int 类型的默认值是 0。

1.5 关于Object类

1.5.1 Object 类的方法

Object 类是所有 Java 类的最终父类，提供了一些基础的方法，这些方法可以分为以下几类：

1.5.1.1 对象比较

  • hashCode()：返回对象的哈希码。

    public native int hashCode();
    • 约定：相等的对象必须具有相等的哈希码。如果重写了 equals 方法，通常也应该重写 hashCode 方法。
    • 示例：
      public int hashCode() {
    return Objects.hash(name, age);
}

  • equals(Object obj)：比较两个对象是否相等。

    public boolean equals(Object obj) {
    return (this == obj);
}
    • 重写：如果需要比较对象的值而不是内存地址，可以重写该方法。
    • 示例：
      class Person1 {
    private String name;
    private int age;

    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj instanceof Person1) {
            Person1 p = (Person1) obj;
            return this.name.equals(p.getName()) && this.age == p.getAge();
        }
        return false;
    }
}
1.5.1.2 对象拷贝
  • clone()：返回对象的一个副本。
    protected native Object clone() throws CloneNotSupportedException;
    • 浅拷贝：默认实现只做浅拷贝。
    • Cloneable 接口：类必须实现 Cloneable 接口，否则会抛出 CloneNotSupportedException 异常。
1.5.1.3 对象转字符串
  • toString()：返回对象的字符串表示。
    public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
    • 重写：通常会被重写以返回更有意义的信息。
    • 示例：
      public String toString() {
    return "Person{" +
            "name='" + name + '\'' +
            ", age=" + age +
            '}';
}
    • IDE 生成：可以使用 IDE（如 IntelliJ IDEA）自动生成 toString 方法。
    • Lombok：使用 @Data 注解自动生成 toString 方法。
1.5.1.4 多线程调度
  • wait()、notify()、notifyAll()：用于线程间的等待/通知机制。
    • 示例：
      public class WaitNotifyDemo {
    public static void main(String[] args) {
        Object lock = new Object();
        new Thread(() -> {
            synchronized (lock) {
                System.out.println("线程1：我要等待");
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程1：我被唤醒了");
            }
        }).start();
        new Thread(() -> {
            synchronized (lock) {
                System.out.println("线程2：我要唤醒");
                lock.notify();
                System.out.println("线程2：我已经唤醒了");
            }
        }).start();
    }
}
    • wait(long timeout)：等待指定时间后自动唤醒。
    • wait(long timeout, int nanos)：更精确的等待时间。
1.5.1.5 反射
  • getClass()：获取对象的类信息。
    public final native Class<?> getClass();
    • 示例：
      public class GetClassDemo {
    public static void main(String[] args) {
        Person p = new Person();
        Class<? extends Person> aClass = p.getClass();
        System.out.println(aClass.getName());
    }
}
1.5.1.6. 垃圾回收
  • finalize()：在对象被垃圾回收前调用，用于清理资源。
    protected void finalize() throws Throwable { }
    • 弃用：Java 9 开始已被弃用，不推荐使用。

1.5.2 关键点总结

  1. 对象比较：hashCode() 和 equals() 方法用于对象的比较。
  2. 对象拷贝：clone() 方法用于对象的浅拷贝。
  3. 对象转字符串：toString() 方法用于返回对象的字符串表示。
  4. 多线程调度：wait()、notify()、notifyAll() 方法用于线程间的等待/通知机制。
  5. 反射：getClass() 方法用于获取对象的类信息。
  6. 垃圾回收：finalize() 方法在对象被垃圾回收前调用，已被弃用。

1.6 关于对象的一些小知识

1.6.1 面向对象编程的基本特征

1.6.1.1 万物皆对象
  • 对象：状态（属性）+ 行为（方法）+ 标识（内存地址）。
  • 消息传递：对象之间通过发送消息进行通信。
  • 组合：通过组合多个对象来创建更复杂的对象。
  • 实例化：对象是通过类实例化的。
  • 接口一致性：同一类型的对象可以接收相同的消息。
1.6.1.2 对象具有接口
  • 类：定义对象的类型，描述对象的特征和行为。
  • 抽象数据类型：创建自定义的数据类型，操作对象（发送消息）。
  • 接口：定义对象可以接收的请求。
  • 实现：具体实现由类的方法完成。
1.6.1.3 访问权限修饰符
  • API 提供者：类的创建者，提供接口。
  • API 调用者：类的使用者，调用接口。
  • 权限修饰符：
    • public：公开访问。
    • private：私有访问，仅类内部可见。
    • protected：受保护访问，子类可见。
    • 默认（包级）：同一包内可见。
  • 作用：保护内部实现，便于修改和维护。
1.6.1.4 组合
  • 复用：将已有类作为成员变量，组合成新类。
  • 关系：has-a 关系。
1.6.1.5 继承
  • 子类继承父类：子类拥有父类的 protected 和 public 方法和字段。
  • 扩展：子类可以添加新方法和字段。
  • 重写：子类可以重写继承的方法。
  • 关系：is-a 关系（仅重写）或 is-like-a 关系（扩展）。
1.6.1.6 多态
  • 定义：同一方法在不同对象中有不同实现。
  • 示例：
    public class Shape {
    public void draw() {
        System.out.println("形状");
    }
}

public class Circle extends Shape {
    @Override
    public void draw() {
        System.out.println("圆形");
    }
}

public class Line extends Shape {
    @Override
    public void draw() {
        System.out.println("线");
    }
}

public class Test {
    public static void main(String[] args) {
        Shape shape1 = new Line();
        shape1.draw(); // 输出: 线
        Shape shape2 = new Circle();
        shape2.draw(); // 输出: 圆形
    }
}
  • 解释：shape1 和 shape2 虽然是 Shape 类型，但调用 draw() 方法时，实际调用的是子类的实现，体现了多态性。

1.6.2 关键点总结

  1. 万物皆对象：对象是状态、行为和标识的组合。
  2. 对象具有接口：类定义对象的类型和接口。
  3. 访问权限修饰符：控制类的访问权限，保护内部实现。
  4. 组合：通过组合已有类创建新类，实现复用。
  5. 继承：子类继承父类，扩展和重写方法。
  6. 多态：同一方法在不同对象中有不同实现，增加灵活性。

1.6.3 进一步理解

  • 抽象：面向对象编程的核心思想之一，通过抽象将复杂问题简化。
  • 封装：通过访问权限修饰符和接口，隐藏内部实现细节，提高代码的可维护性。
  • 继承与组合：继承用于类之间的层次关系，组合用于对象之间的组合关系，各有优劣。
  • 多态：增加代码的灵活性和可扩展性，是面向对象编程的重要特性。

2 Java中的包

2.1 关于包

2.1.1 包的作用

  • 解决命名冲突：通过包名来区分同名的类，避免命名冲突。
  • 组织代码：将相关的类组织在一起，便于管理和维护。

2.1.2 包的声明

  • 语法：在 Java 文件的第一行使用 package 关键字声明包名。
    package ming; // 声明包名 ming
public class Person {
}
  • 完整类名：类的完整类名是 包名.类名。例如，ming.Person。

2.1.3 包的层次结构

  • 多层结构：包名可以有多层结构，用 . 隔开。例如，java.util。
  • 没有父子关系：包之间没有继承关系。例如，java.util 和 java.util.zip 是不同的包。

2.1.4 包的组织

  • 目录结构：Java 文件的目录结构应与包的层次结构一致。
    package_sample
└─ src
    ├─ hong
    │  └─ Person.java
    │  ming
    │  └─ Person.java
    └─ mr
       └─ jun
          └─ Arrays.java
  • 编译后的目录结构：编译后的 .class 文件也需要按照包结构存放。
    package_sample
└─ bin
    ├─ hong
    │  └─ Person.class
    │  ming
    │  └─ Person.class
    └─ mr
       └─ jun
          └─ Arrays.class

2.1.5 编译命令

  • 命令行编译：在 src 目录下执行 javac 命令，指定输出目录。
    javac -d ../bin ming/Person.java hong/Person.java mr/jun/Arrays.java
  • IDE 自动编译：在 IDE 中，会自动根据包结构编译所有 Java 源码，无需手动执行编译命令。

2.1.6 关键点总结

  1. 解决命名冲突：通过包名区分同名类。
  2. 组织代码：将相关类组织在一起，便于管理和维护。
  3. 包的声明：在 Java 文件的第一行使用 package 关键字声明包名。
  4. 完整类名：类的完整类名是 包名.类名。
  5. 包的层次结构：包名可以有多层结构，用 . 隔开。
  6. 目录结构：Java 文件和编译后的 .class 文件的目录结构应与包的层次结构一致。
  7. 编译命令：在命令行中使用 javac 命令编译 Java 文件，指定输出目录。

2.1.7 进一步理解

  • 默认包：没有定义包名的类属于默认包，容易引起命名冲突，不推荐使用。
  • 包的导入：使用 import 关键字导入其他包中的类，简化类名的使用。
    import ming.Person;
  • 包的权限：包内的类默认具有包级访问权限，可以相互访问。

2.2 包的作用域

2.2.1 包的作用域

  • 定义：在同一个包内的类可以访问包作用域的字段和方法。
  • 修饰符：不用 public、protected、private 修饰的字段和方法就是包作用域。

2.2.2 示例代码

2.2.2.1 Person 类
package hello;

public class Person {
    // 包作用域方法
    void hello() {
        System.out.println("Hello!");
    }
}
  • 包作用域方法：hello() 方法没有使用 public、protected、private 修饰符，因此它是包作用域的。
2.2.2.2 Main 类
package hello;

public class Main {
    public static void main(String[] args) {
        Person p = new Person();
        p.hello(); // 可以调用，因为 Main 和 Person 在同一个包
    }
}
  • 访问包作用域方法：Main 类和 Person 类在同一个包 hello 中，因此可以访问 Person 类的包作用域方法 hello()。

2.2.3 关键点总结

  1. 包作用域：在同一个包内的类可以访问包作用域的字段和方法。
  2. 修饰符：不用 public、protected、private 修饰的字段和方法就是包作用域。
  3. 访问权限：包作用域的字段和方法只能在同一个包内访问。

2.2.4 进一步理解

  • 默认访问权限：包作用域也称为默认访问权限（default access），在 Java 中，如果没有显式指定访问修饰符，默认就是包作用域。
  • 包的组织：通过包的组织，可以将相关的类放在同一个包中，便于管理和访问。
  • 访问控制：Java 提供了四种访问修饰符：public、protected、private 和默认（包作用域），用于控制类的访问权限。
    • public：公开访问，任何类都可以访问。
    • protected：受保护访问，同一个包内的类和子类可以访问。
    • private：私有访问，仅类内部可见。
    • 默认（包作用域）：同一个包内的类可以访问。

2.3 导入包

2.3.1 引用其他类的方法

在 Java 中，引用其他类有三种主要方法：

2.3.1.1 直接写出完整类名
// Person.java
package ming;

public class Person {
    public void run() {
        mr.jun.Arrays arrays = new mr.jun.Arrays();
    }
}
  • 优点：明确指出类的完整路径。
  • 缺点：每次都要写完整的类名，比较繁琐。
2.3.1.2 使用 import 语句
// Person.java
package ming;

// 导入完整类名:
import mr.jun.Arrays;

public class Person {
    public void run() {
        Arrays arrays = new Arrays();
    }
}
  • 优点：简化类名的使用。
  • 缺点：需要手动导入每个类。
2.3.1.3 使用 import 语句导入包中的所有类
// Person.java
package ming;

// 导入mr.jun包的所有class:
import mr.jun.*;

public class Person {
    public void run() {
        Arrays arrays = new Arrays();
    }
}
  • 优点：简化导入多个类。
  • 缺点：难以看出类属于哪个包，不推荐使用。

2.3.2 import static 语法

package main;

// 导入System类的所有静态字段和静态方法:
import static java.lang.System.*;

public class Main {
    public static void main(String[] args) {
        // 相当于调用System.out.println(…)
        out.println("Hello, world!");
    }
}
  • 优点：简化静态字段和方法的调用。
  • 缺点：使用较少，容易引起混淆。

2.3.3 编译器查找类名的规则

  1. 完整类名：直接根据完整类名查找类。
  2. 简单类名：按以下顺序查找：
    • 查找当前包是否存在这个类。
    • 查找 import 的包是否包含这个类。
    • 查找 java.lang 包是否包含这个类。
  3. 编译错误：如果按照上述规则无法确定类名，则编译报错。

2.3.4 示例代码

// Main.java
package test;

import java.text.Format;

public class Main {
    public static void main(String[] args) {
        java.util.List list; // ok，使用完整类名 -> java.util.List
        Format format = null; // ok，使用import的类 -> java.text.Format
        String s = "hi"; // ok，使用java.lang包的String -> java.lang.String
        System.out.println(s); // ok，使用java.lang包的System -> java.lang.System
        MessageFormat mf = null; // 编译错误：无法找到MessageFormat: MessageFormat cannot be resolved to a type
    }
}

2.3.5 自动导入

  • 默认自动导入：编译器会自动导入当前包的其他类和 java.lang.* 包。
  • 手动导入：类似 java.lang.reflect 这样的包仍需要手动导入。

2.3.6 类名冲突

  • 解决方法：如果有两个类名相同，例如 mr.jun.Arrays 和 java.util.Arrays，只能 import 其中一个，另一个必须写完整类名。

2.3.7 关键点总结

  1. 直接写出完整类名：明确指出类的完整路径，但繁琐。
  2. 使用 import 语句：简化类名的使用，需要手动导入每个类。
  3. 使用 import 语句导入包中的所有类：简化导入多个类，但不推荐使用。
  4. import static 语法：简化静态字段和方法的调用，使用较少。
  5. 编译器查找类名的规则：优先使用完整类名，然后查找当前包、import 的包和 java.lang 包。
  6. 自动导入：编译器自动导入当前包的其他类和 java.lang.* 包。
  7. 类名冲突：如果有类名冲突，只能 import 其中一个，另一个必须写完整类名。

2.4 包的最佳实践

2.4.1 包名的命名规范

  • 唯一性：为了避免名字冲突，推荐使用倒置的域名来确保包名的唯一性。
    • 示例：
      org.apache
org.apache.commons.log
com.tobebetterjavaer.sample
  • 子包命名：子包可以根据功能自行命名，保持清晰和有意义。

2.4.2 避免命名冲突

  • 避免与 java.lang 包的类重名：不要使用 java.lang 包中的类名作为自己的类名。
    • 示例：
      String
System
Runtime
  • 避免与 JDK 常用类重名：不要使用 JDK 常用类的名字作为自己的类名。
    • 示例：
      java.util.List
java.text.Format
java.math.BigInteger

2.4.3 关键点总结

  1. 唯一性：使用倒置的域名来确保包名的唯一性。
  2. 子包命名：子包可以根据功能自行命名，保持清晰和有意义。
  3. 避免与 java.lang 包的类重名：不要使用 java.lang 包中的类名作为自己的类名。
  4. 避免与 JDK 常用类重名：不要使用 JDK 常用类的名字作为自己的类名。

3 参考链接

  1. Object和类，万物皆对象
  2. package包
·云扬·
关注
专栏目录
Java面向对象基础编程练习题
weixin_43799374的博客
09-11 2180
Java面向对象基础编程练习题 1、编写 Car 类，属性有品牌（brand）和颜色（Color）， 定义 show 方法，打印所有属性。 package com.wang.task10201001.pojo; /* * 1、编写 Car 类，属性有品牌（brand）和颜色（Color）， * 定义 show 方法，打印所有属性。 */ public class Car { //属性 private String brand;//品牌 private String color;//颜色 /
java面向对象编程总结
weixin_64926930的博客
04-29 1513
在经过十周的java学习后，我对于原本一窍不通的课程又有了新的理解，它也并不是原本我不认识之前高冷的模样，我在慢慢的接触它，认识它，了解它。但现在为止，我对于我所学习的java中的“面向对象编程”做一个个人总结，其中观点仅代表个人，如有错误，敬请纠正。 在我所学习的教材中，将“面向对象编程”分为1,2,3三个章节，我也将我所学习的内容分为三个点来进行总结。 面向对象编程1 什么是面向对象 在这个章节里面，我们知道了什么是面向对象，如果用一个比喻来说的话，面向对象就像是养花一样，买个花瓶，再买束鲜花，不喜
Java 基础入门篇（五）：面向对象编程
秀岩的博客
04-30 2843
一、面向对象的思想 二、类的定义与对象的创建 三、对象内存分配情况 3.1 两个对象的内存图 3.2 两个变量指向同一个对象内存图 四、构造器 4.1 构造器的格式与分类 4.2 构造器的调用 五、 this 关键字 六、封装 七、标准JavaBean 补充：局部变量和成员变量的区别
【JAVA-Day62】Java继承：面向对象编程中重要的基石
沉淀、分享、成长，让自己和他人都能有所收获！
12-11 1万+
本技术博客将深入研究Java中继承的核心概念，探寻其在面向对象编程中的重要地位。通过对继承的本质、倡导原因、技巧、与封装、多态的融合，以及面试考点的深入理解，我们将为你呈现继承的全貌，揭示其在实际开发中的价值和实践总结。总结使用继承的最佳实践，给出一系列注意事项，并强调在实际开发中应用这些技巧的重要性。深入理解并掌握继承的技巧可以帮助你更加灵活地设计和构建面向对象的应用程序，并有效地避免继承可能带来的潜在问题。详细解释继承的概念，子类如何从父类继承属性和方法。
Java基础：面向接口编程详解
TuT
04-03 1万+
我想，对于各位使用面向对象编程语言的程序员来说，“接口”这个名词一定不陌生，但是不知各位有没有这样的疑惑：接口有什么用途？它和抽象类有什么区别？能不能用抽象类代替接口呢？而且，作为程序员，一定经常听到“面向接口编程”这个短语，那么它是什么意思？有什么思想内涵？和面向对象编程是什么关系？本文将一一解答这些疑问。 面向接口编程和面向对象编程是什么关系 首先，面向接口编程和面向对象编程并不是平级的，它并...
【JAVA-Day59】方法重写：面向对象编程中的重要概念
热门推荐
沉淀、分享、成长，让自己和他人都能有所收获！
12-10 1万+
方法重写是指子类重新定义父类中已有的方法的过程。它允许我们使用不同的实现方式来覆盖父类中的方法，为面向对象编程带来了灵活性和可扩展性。方法重写是 Java 中一种实现多态性的机制。当子类继承自父类时，子类可以重写父类中已经存在的方法，以实现自己的特定逻辑或行为。方法重写要求子类中的方法与父类中被重写的方法具有相同的方法名称、参数列表和返回类型。子类中的重写方法必须与父类中的被重写方法具有相同的方法签名。重写方法的访问修饰符不能比被重写方法的访问修饰符更严格。
Java面向对象浅谈
编程界明世隐的博客
12-06 5058
作者简介 作者名：编程界明世隐 简介：CSDN博客专家，从事软件开发多年，精通Java、JavaScript，博主也是从零开始一步步把学习成长、深知学习和积累的重要性，喜欢跟广大ADC一起打野升级，欢迎您关注，期待与您一起学习、成长、起飞！ 热门专栏推荐 【1】Java小游戏（俄罗斯方块、飞机大战、植物大战僵尸等） 【2】JavaWeb项目实战（图书管理、在线考试、宿舍管理等） 【3】JavaScript精彩实例（飞机大战、贪吃蛇、验证码等） 【4】Java小白入门200例 【5】从零学Java、趣学J
JAVA学习（五）：Java面向对象编程基础
成长Bar的博客专栏
07-05 1676
Java面向对象编程基础 面向对象（Object oriented programming，OOP）技术是一种强有力的软件开发方法，它采用数据抽象与信息隐藏技术，来使软件开发简单化，以达到代码重用的目的。 1、OOP的3个特性（封装、继承和多态性） 封装是类的基础，指把类的相关实现细节隐藏起来，在类中将数据和实现操作的代码集中起来放在对象的内部，调用这些类时只需直接使
Java基础：面向对象4大特性：抽象，封装，继承，多态
weixin_42188778的博客
05-01 3314
一、背景。 这篇文章主要介绍了面向对象4大特性：抽象，封装，继承，多态详细教程,本文通过图文并茂的形式给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下。放假在家里休息，闲来无事，想巩固巩固自己的基础知识。Java基础这个我会一直更新的，希望大家关注 收藏 点赞。 二、面向对象4大特性：抽象，封装，继承，多态。 1.抽象： 在类的设计层次：将某些事务的共同属性提取出来集合到一个类；类与对象之间的关系：类时抽象的，对象是具体的，类是对象的模板，对象的创建时以类未模板的
java基础-面向对象
codeglory的博客
04-21 6284
java基础部分-面向对象的概念，类之间关系，并部分解释了UML类图
java面向对象编程pdf
04-16
在这篇文章中，我们将对Java面向对象编程的基础知识进行总结和解释。面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，它将程序设计看作是对象的交互，对象之间的关系和行为。 一、对象和类 在...
Java 基础之面向对象编程教程
01-22
Java 基础之面向对象编程教程，主要类和对象、如何定义类、成员函数、访问控制修饰符、构造方法、类变量、类方法、方法重载、方法覆盖、抽象、封装、继承、多态、抽象类、接口和New 运算符等概念的介绍和例题介绍...
漫画面向对象编程 Java
06-16
借助于漫画展示的形式，面向对象的简、由类创建一个对象的方法、类的编写与对象的创建、类的构造函数、类的方法、修饰符、... 可以在轻松幽默的氛围中对面向对象编程产生浓厚的兴趣，从而为后续的编程进阶树立信心。
阿里云大学-零基础学Java10系列二：面向对象编程-项目代码.rar
05-14
1.阿里云大学课程链接 https://edu.aliyun.com/course/1011?spm=5176.11400004.0.0.15f24768TEzFYJ 2.课程无附件代码，自己跑的结果，共享之。没有严格的一课时一文件，里头可能还有一部分 系列一的代码
Java-Java面向对象编程教程
11-13
除了这些基础概念，Java面向对象编程还包括其他重要主题，如构造器、抽象类和接口、异常处理、包（Package）、访问修饰符和内部类等。构造器用于初始化新创建的对象；抽象类不能被实例化，但可以被其他类继承；接口...
C++学习笔记----8、掌握类与对象（四）---- 不同类型的数据成员（1）
weixin_71738303的博客
10-05 926
c++对于数据成员给了你许多选项。除了在类中声明简单的数据成员，可以生成静态数据成员供所有类的对象共享，const成员，引用成员，reference-to-const成员，等等。本节我们解释一下这些不同类型的数据成员的细节。
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1216
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
JDK1.0主要特性
最新发布
FoolRabbit的专栏
10-06 359
JDK1.0主要特性。
Spring依赖注入和注解驱动详解和案例示范
J老熊
10-01 1017
在 Spring 框架中，依赖注入（Dependency Injection, DI）和注解驱动（Annotation-Driven）是其核心机制，它们为 Spring 应用提供了灵活性和可扩展性。依赖注入简化了对象间的依赖管理，而注解驱动则通过简洁的注解配置取代了繁琐的 XML 配置。本文将详细分析这两个机制，并通过示例加深理解。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值