面向对象基础小结

面向对象基础小结

面向对象和面向过程的区别

两者的主要区别在于解决问题的方式不同：

  • 面向过程：是把解决问题的过程拆成一个个方法，通过一个个方法的执行解决问题。
  • 面向对象：会先抽象出对象，然后用对象执行方法的方式解决问题。

面向对象开发的程序一般更易维护、易复用、易扩展。

求圆的面积和周长的示例

面向过程：

直接定义圆的半径，并使用该半径直接计算出圆的面积和周长(即将问题的过程拆分成了两个方法来解决）。

public class Main {
    public static void main(String[] args) {
        // 定义圆的半径
        double radius = 3.0;

        // 计算圆的面积和周长
        double area = Math.PI * radius * radius;
        double perimeter = 2 * Math.PI * radius;

        // 输出圆的面积和周长
        System.out.println("圆的面积为：" + area);
        System.out.println("圆的周长为：" + perimeter);
    }
}

面向对象：

定义一个 Circle 类来表示圆（即先抽象出一个对象），该类包含了圆的半径属性和计算面积、周长的方法（用对象的方法解决问题）。

public class Circle {
    // 定义圆的半径
    private double radius;

    // 构造函数
    public Circle(double radius) {
        this.radius = radius;
    }

    // 计算圆的面积
    public double getArea() {
        return Math.PI * radius * radius;
    }

    // 计算圆的周长
    public double getPerimeter() {
        return 2 * Math.PI * radius;
    }

    public static void main(String[] args) {
        // 创建一个半径为3的圆
        Circle circle = new Circle(3.0);

        // 输出圆的面积和周长
        System.out.println("圆的面积为：" + circle.getArea());
        System.out.println("圆的周长为：" + circle.getPerimeter());
    }
}

创建一个对象用什么运算符？对象实体与对象引用有何不同?

用 new 运算符。

  • new 创建对象实例（对象实例在堆内存中），
  • 对象引用指向对象实例（对象引用存放在栈内存中）。
  • 一个对象可以有 n 个引用指向它（可以用 n 条绳子系住一个气球）
  • 一个对象引用可以指向 0 个或 1 个对象（一根绳子可以不系气球，也可以系一个气球）

对象的相等和引用相等的区别

  • 对象的相等一般比较的是内存中存放的内容是否相等。
  • 引用相等一般比较的是他们指向的内存地址是否相等。
String str1 = "hello";
String str2 = new String("hello");
String str3 = "hello";
// 使用 == 比较字符串的引用相等
System.out.println(str1 == str2); // false -- 一个在常量池中，一个在堆内存中
System.out.println(str1 == str3); // true -- 都在常量池中
// 使用 equals 方法比较字符串的相等
System.out.println(str1.equals(str2)); // true
System.out.println(str1.equals(str3)); // true

构造方法有哪些特点？是否可被 override?

构造方法特点如下：

  • 名字与类名相同。
  • 没有返回值，但不能用 void 声明构造函数。
  • 生成类的对象时自动执行，无需调用。
public class Person {
    private String name;
    private int age;
    
    // 构造方法没有返回值，并且不能用void声明构造函数
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public void display() {
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
    }
    public static void main(String[] args) {
        // 生成对象时自动执行构造方法
        Person person = new Person("John", 25);
        person.display();
    }
}

构造方法不能被 override（重写）,但是可以 overload（重载）,所以你可以看到一个类中有多个构造函数的情况

面向对象三大特征

面向对象编程的三大特征是：封装、继承和多态。

  1. 封装（Encapsulation）：封装是将对象的属性和方法组合在一起，形成一个独立的、自包含的整体，对外部隐藏对象的内部细节，只向外部提供公共接口（方法），以便外部的代码能够通过这些接口访问对象。封装可以提高代码的可维护性和重用性，同时也可以保护对象的数据安全。

    // 例如 封装一个实体类
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 int getAge() {
        return age;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

  2. 继承（Inheritance）：继承是指在已有类的基础上，创建一个新的类，并且让新类拥有已有类的属性和方法。被继承的类称为父类或基类，继承的类称为子类或派生类。子类可以在不重复编写代码的情况下，拥有父类的公共属性和方法，同时还可以增加自己的属性和方法，以实现更加复杂的功能。

    // 继承上面那个父类，下面这个是子类
public class Student extends Person {
    private int grade;
    public Student(String name, int age, int grade) {
        super(name, age);
        this.grade = grade;
    }
    public int getGrade() {
        return grade;
    }
    public void setGrade(int grade) {
        this.grade = grade;
    }
}

  3. 多态（Polymorphism）：多态是指同一个方法调用，由于对象不同可能会产生不同的行为。多态可以让不同的对象对同一个消息做出不同的响应，从而提高代码的灵活性和可扩展性。多态有两种实现方式：静态多态（重载）和动态多态（重写和接口实现）。

    • 在 Java 中，多态的实现主要依赖于两个机制：继承和方法重写。

    • 调用子类中重写的 move() 方法，从而产生不同的行为。这就是多态的体现。

    // 多态示例代码
public class Animal {
    public void move() {
        System.out.println("Animal move");
    }
}
public class Dog extends Animal {
    public void move() {
        System.out.println("Dog move");
    }
}
public class Cat extends Animal {
    public void move() {
        System.out.println("Cat move");
    }
}
public class Main {
    public static void main(String[] args) {
        Animal a1 = new Animal();
        Animal a2 = new Dog(); // 使用子类对象替换父类对象
        Animal a3 = new Cat(); // 使用子类对象替换父类对象
        a1.move();
        a2.move();
        a3.move();
    }
}

注意，三个对象指定的都是 父类（Animal）

关于继承如下 3 点需要记住：

  1. 子类拥有父类对象所有的属性和方法（包括私有属性和私有方法），但是父类中的私有属性和方法子类是无法访问，只是拥有。
  2. 子类可以拥有自己属性和方法，即子类可以对父类进行扩展。
  3. 子类可以用自己的方式实现父类的方法。

子类无法直接访问父类的私有属性和方法

class ParentClass {
    private String privateProperty = "Private property";

    public void publicMethod() {
        System.out.println("Public method");
    }

    private void privateMethod() {
        System.out.println("Private method");
    }
}

class ChildClass extends ParentClass {
    public void childMethod() {
        System.out.println("Child method");
        System.out.println(publicProperty); // 子类可以访问父类的公有属性
        publicMethod(); // 子类可以调用父类的公有方法
        // 子类无法访问父类的私有属性和私有方法
        // System.out.println(privateProperty); // 这行代码会报错
        // privateMethod(); // 这行代码会报错
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建子类对象
        ChildClass child = new ChildClass();

        // 子类对象可以访问和调用父类的公有属性和方法
        System.out.println(child.publicProperty);
        child.publicMethod();
    }
}

子类可以间接访问父类的私有成员 – 所以说拥有

class ParentClass {
    private String privateProperty = "Private property";

    private void privateMethod() {
        System.out.println("Private method");
    }

    public void accessPrivateMembers() {
        System.out.println(privateProperty); // 子类间接访问父类的私有属性
        privateMethod(); // 子类间接调用父类的私有方法
    }
}

class ChildClass extends ParentClass {
    // 子类继承了父类的私有属性和私有方法，但无法直接访问

    public void accessParentPrivateMembers() {
        accessPrivateMembers(); // 子类间接访问父类的私有成员
    }
}

public class Main {
    public static void main(String[] args) {
        ChildClass child = new ChildClass();
        child.accessParentPrivateMembers();
    }
}

多态的特点:

  • 对象类型（父类）和引用类型（子类）之间具有继承（类）/实现（接口）的关系；
  • 引用类型变量发出的方法调用的到底是哪个类中的方法，必须在程序运行期间才能确定；
  • 多态不能调用“只在子类存在但在父类不存在”的方法；（多态指向的都是父类）
  • 如果子类重写了父类的方法，真正执行的是子类覆盖的方法，如果子类没有覆盖父类的方法，执行的是父类的方法。

接口和抽象类有什么共同点和区别？

interface 和 abstract

共同点：

  • 都不能被实例化。
  • 都可以包含抽象方法。
  • 都可以有默认实现的方法（Java 8 可以用 default 关键字在接口中定义默认方法）。

区别：

  • 【接口】主要用于对类的行为进行约束，你实现了某个接口就具有了对应的行为。【抽象类】主要用于代码复用，强调的是所属关系。
  • 一个类只能继承一个类，但是可以实现多个接口。
  • 【接口】中的成员变量只能是 public static final 类型的，不能被修改且必须有初始值，而【抽象类】的成员变量默认 default，可在子类中被重新定义，也可被重新赋值。
// 定义一个接口
public interface Animal {
    public void eat();
}
// 定义一个抽象类
public abstract class Vehicle {
    private int speed;
    public void setSpeed(int speed) {
        this.speed = speed;
    }
    public int getSpeed() {
        return speed;
    }
    public abstract void run(); // 抽象方法
}
// 实现接口
public class Dog implements Animal {
    public void eat() {
        System.out.println("The dog is eating.");
    }
}
// 继承抽象类
public class Car extends Vehicle {
    public void run() {
        System.out.println("The car is running.");
    }
}
// 测试类
public class Test {
    public static void main(String[] args) {
        // 使用接口
        Animal animal = new Dog();
        animal.eat(); // The dog is eating.
        // 使用抽象类
        Vehicle vehicle = new Car();
        vehicle.setSpeed(60);
        System.out.println("The speed of the car is " + vehicle.getSpeed() + " km/h."); // The speed of the car is 60 km/h.
        vehicle.run(); // The car is running.
    }
}

深拷贝和浅拷贝的区别了解吗？什么是引用拷贝？

【深拷贝】会完全复制整个对象，会在堆上新创建一个地址（原对象的内部对象 Address）；

而【浅拷贝】只会在堆上新创建一个对象，但是内部地址还是原对象的，与原对象共用一个 Address 对象。

【引用拷贝】不会创建一个新的对象，而只是单纯的引用堆里面的原对象。

  System.out.println("The speed of the car is " + vehicle.getSpeed() + " km/h."); // The speed of the car is 60 km/h.
        vehicle.run(); // The car is running.
    }
}

深拷贝和浅拷贝的区别了解吗？什么是引用拷贝？

【深拷贝】会完全复制整个对象，会在堆上新创建一个地址（原对象的内部对象 Address）；

而【浅拷贝】只会在堆上新创建一个对象，但是内部地址还是原对象的，与原对象共用一个 Address 对象。

【引用拷贝】不会创建一个新的对象，而只是单纯的引用堆里面的原对象。
在这里插入图片描述

学习参考

Java基础常见面试题总结(中) | JavaGuide(Java面试 + 学习指南)

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/196008.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Deepin使用记录-deepin系统开启SSH服务

Deepin使用记录-deepin系统开启SSH服务

1、检查安装的deepin系统是否已经开启SSH功能。 $ ps -e | grep ssh $ ps -e | grep ssh 查看是否启动ssh 2、安装openssh-server服务 sudo apt-get install openssh-server 如果出现以上提示，就表示你已经安装了ssh服务，只是还没有启动。 3、安装完…
阅读更多...
大模型fine-tune 微调

大模型fine-tune 微调

大模型的 Fine-tune 我们对技术的理解，要比技术本身更加重要。 正如我在《大模型时代的应用创新范式》一文中所说，大模型会成为AI时代的一项基础设施。 作为像水、电一样的基础设施，预训练大模型这样的艰巨任务，只会有少数技术…
阅读更多...
关于Linux服务器高并发场景下系统参数优化的诸多奇技淫巧

关于Linux服务器高并发场景下系统参数优化的诸多奇技淫巧

文章目录 🔊博主介绍🥤本文内容开篇内存优化——马达与燃油磁盘优化——加油与换胎网络参数优化——挂挡与提速进程优化——适度开疆拓土 📢文章总结📥博主目标 🔊博主介绍 🌟我是廖志伟，一名Ja…
阅读更多...
设二维数组a[1...m，1...n]（）含有m*n个整数。写一个算法判断a中所有元素是否互不相同，并输出相关信息（yes/no)

设二维数组a[1...m，1...n]（）含有m*n个整数。写一个算法判断a中所有元素是否互不相同，并输出相关信息（yes/no)

设二维数组a[1…m，1…n]（）含有m*n个整数。 写一个算法判断a中所有元素是否互不相同，并输出相关信息（yes/no) 分析其时间复杂度 代码思路： 这种如果纯暴力做的话时间复杂度非常高。 我这里考虑把题目中的二…
阅读更多...
「Linux」git的安装与使用

「Linux」git的安装与使用

💻文章目录 📄前言安装git的使用配置git初始化 git 仓库提交文件推送到远端使用HTPPS方式：SSH方式 📓总结 📄前言 git是一款多平台的版本管理器，用于对代码进行版本控制，如果你还不知如何安装gi…
阅读更多...
虚幻学习笔记6—摄像机控制

虚幻学习笔记6—摄像机控制

一、前言 摄像机在虚幻中的应用是最常见的。如通常在游戏或应用中会常常出现需要切换不同视角的情况、摄像机拉近缩小等，这个在虚幻中是怎么实现的呢。 二、实现视点切换 2.1、提前设置场景的视点：如图2.1.1所示添加一个摄像机视点到关卡场景中&#x…
阅读更多...
Java数据结构之优先级队列(PriorityQueue)

Java数据结构之优先级队列(PriorityQueue)

1、概念 队列：是一种FIFO（First-In-First-Out）先进先出的数据结构，对应于生活中的排队的场景， 排在前面的人总是先通过，依次进行。 优先队列：是特殊的队列，从“优先”一词&#xff…
阅读更多...
计算机网络（超详解！） 第一节计算机网络的性能指标

计算机网络（超详解！） 第一节计算机网络的性能指标

1.速率 比特（bit）是计算机中数据量的单位，也是信息论中使用的信息量的单位。 比特（bit）来源于 binary digit，意思是一个“二进制数字”，因此一个比特就是二进制数字中的一个 1 或 0。 速率是…
阅读更多...
游戏软件的设计方法

游戏软件的设计方法

游戏软件的设计是一个综合性的过程，涉及到多个方面，包括游戏概念、用户体验、技术实现等。以下是一般的游戏软件设计方法，希望对大家有所帮助。北京木奇移动技术有限公司，专业的软件外包开发公司，欢迎交流合作。 明确游…
阅读更多...
第二十章(多线程)

第二十章(多线程)

一.线程的简介 Windows操作系统是多任务操作系统，它以进程为单位。一个进程是一个包含有自身地址的程序，每个独立执行的程序都称为进程。也就是说每个正在执行的程序都是一个进程。系统可以分配给每一个进程有一段有限的使用CPU的时间（也可以…
阅读更多...
解释LED显示屏的裸眼3D特效原理

解释LED显示屏的裸眼3D特效原理

LED电子大屏幕的3D特效技术正在不断发展，而实现这一技术的原理主要包括分光、分色、分时和光栅等四种方法。这些原理都有各自的特点和应用场景，下面将对它们进行详细介绍。 1. 分光方法 分光方法是一种基于偏振光的3D显示技术。通过使用偏振滤镜或偏振片…
阅读更多...
RISC-V_WCH系列微控器软件体系云端快速架构

RISC-V_WCH系列微控器软件体系云端快速架构

1 概述 RISC-V内核的微控器MCU，正在以更高的性价比，快速取代传统的各类ARM系列微控制处理器。 针对常用的芯成RISC-V内核的泌恒WCH系列微控器MCU，推出了：RISC-V_WCH系列微控器软件体系快速架构云平台。只要以身份证号码做用户名…
阅读更多...
好看的css样式案例网站

好看的css样式案例网站

uiverse 网站地址：https://uiverse.io/all 比如说我们要这个案例的代码 点击get code就可以了 右侧有完整的示例代码。 svg波浪生成器 网站：https://getwaves.io/ 根据自己需求调节好之后点击这个下载按钮就可以了
阅读更多...
如何把视频中不需要的人物去掉？

如何把视频中不需要的人物去掉？

从视频中移除不想要的对象或区域，这项工作以前既繁琐复杂又很消耗时间。但使用“AI智能抠像”工具，只需几个简单的步骤，即可轻松移除视频中任何不想要的人物。 在制作视频的过程中，我们常常会遇到需要将视频中多余的人物去掉的情…
阅读更多...
Python基础语法之学习type()函数

Python基础语法之学习type()函数

Python基础语法之学习type函数 一、代码二、效果 查看数据类型或者说查看变量存储的数据类型 一、代码 print(type("文本")) print(type(666)) print(type(3.14))二、效果 梦想是生活的指南针，坚持追逐梦想，终将抵达成功的彼岸。不要害怕失败…
阅读更多...
递归实现全排列

递归实现全排列

思路: 对于给定的集合，选择一个元素作为当前位置的元素。将当前位置的元素与集合中其他位置的元素交换，依次产生新的排列。通过递归调用，将当前位置向后移动，继续生成新的排列。当当前位置达到集合的末尾时，表示生成了…
阅读更多...
万字解析设计模式之观察者模式、中介者模式、访问者模式

万字解析设计模式之观察者模式、中介者模式、访问者模式

一、观察者模式 1.1概述 观察者模式是一种行为型设计模式，它允许一个对象（称为主题或可观察者）在其状态发生改变时，通知它的所有依赖对象（称为观察者）并自动更新它们。这种模式提供了一种松耦合的方式&…
阅读更多...
国产操作系统-银河麒麟V10

国产操作系统-银河麒麟V10

一、介绍 银河麒麟操作系统隶属于麒麟软件，麒麟软件是专业从事国产操作系统研发和产业化的企业，面向通用和专用领域打造安全创新的国产操作系统产品和相应解决方案，旗下拥有银河麒麟、中标麒麟、星光麒麟三大产品品牌。 麒麟软件官方网站地…
阅读更多...
运行新vue3项目

运行新vue3项目

一，下载node并安装 官网：https://nodejs.org/en/ 查看版本： node -v二，cd进入到vue3项目目录 cd D:\Program-space\HBuilderXProject\Vue3project三，npm install npm install四，查看安装 npm list五&a…
阅读更多...
Django回顾2

Django回顾2

目录 一.HTTP 1.URL介绍 2.格式： 3.补充： 二.web框架 1.什么是框架 2.什么是web框架 3.wsgi协议 基于wsgi协议的web服务器： 4.协议是怎么规定的 三.Django 1.MVC与MTV模型（所有框架其实都遵循MVC架构） 2.…
阅读更多...
最新文章

Copyright @ 2022~2023