AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

【前端学java】面向对象编程基础-类的使用(4)

2024-08-13 19
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 【8月更文挑战第9天】面向对象编程基础-类的使用

java中的类语法和前端的类语法几乎是一致的。

基础代码示例

JAVA的面向对象编程和JS的类语法十分接近，我们看一段代码

public class Object_oriented {
   
   
    public static void main(String[] args) {
   
   
        // 打工人 前的PeoPle是类型
        People dagongren =new People();
        dagongren.name = "zhangsan";
        dagongren.speak();
    }
}

class People {
   
   
    String name;
    void speak(){
   
   
        System.out.println("卧槽，" + name +"讲话了！");
    }
}

上述代码包含一个名为Object_oriented的Java类和一个名为People的Java类。
Object_oriented类是程序的入口点，具有一个静态的main方法，是程序的执行起点。在main方法中，创建了一个People对象，名为dagongren，并设置了其name属性为"zhangsan"。接着调用了dagongren对象的speak方法。
People类是一个自定义的类，具有一个name属性和一个speak方法。name属性是一个字符串，存储了一个人的名字。
11.gif

类的属性

在Java类中，属性也称为成员变量或实例变量，是类的特征和状态的表示。

属性可以是任何基本数据类型（如整数、浮点数、字符、布尔值等）或引用数据类型（如字符串、数组、对象等）。

属性的声明语法如下：

<访问修饰符> <数据类型> <属性名>;

访问修饰符用于控制属性的可见性和访问范围：

  • public：可以从任何地方访问。
  • private：只能在同一个类中访问。
  • protected：可以在同一个包内或子类中访问。
  • 默认（不写修饰符）：可以在同一个包内访问。

例如，以下是一个包含三个属性的示例：

public class Person {
   
   
  public String name;     // 公开的name属性
  private int age;        // 私有的age属性
  protected boolean sex;   // 受保护的sex属性
  // 构造方法和其他方法...
}

在上面的示例中，Person类有三个属性：name、age和sex。name属性是公开的，可以从类外部访问。age属性是私有的，只能在Person类内部访问。sex属性是受保护的，可以在同一个包内或Person类的子类中访问。

类的方法

类的方法和TS中的方法基本一致，类中的方法需要添加返回类型
方法由方法头和方法体组成。方法头包括方法的修饰符、返回类型、方法名称和参数列表。

修饰符 返回类型 方法名(参数列表) {
    // 方法体
}
  • 修饰符指定方法的访问方式（public、private、protected等）
  • 返回类型指定方法返回的数据类型（如果没有返回值则使用关键字void）
  • 方法名是方法的标识符
  • 参数列表列出方法接受的参数。

我们可以看一个简单的demo

public class Object_oriented {
   
   
  public static void main(String[] args) {
   
   
    People dagongren =new People();
    dagongren.eat = true;
    dagongren.speak();
  }
}
class People {
   
   
  boolean eat;
  void speak(){
   
   
    System.out.println(getText());
  }
  String getText(){
   
   
    if(this.eat) {
   
   
      return "我吃饭了";
    }else {
   
   
      return "我没吃饭";
    }
  }
}

方法中引入类的属性可以使用this关键词
方法中可以引入类中的其他方法

如果类中的方法需要参数，其写法和js也是一致的，不过需要指定参数的类型，如

public void add(int num1, int num2) {
   
   
  // 方法体
}

静态

静态成员

静态变量是与类关联的变量，可以理解为类自身的属性，实例对象是木有的。静态变量可以用类名直接访问，而不需要创建类的实例。例如：

public class MyClass {
   
   
  static int count;
}

使用类名访问静态成员变量。例如：MyClass.count = 10;

静态方法

静态方法是与类关联的方法。与静态变量一样，无需创建类的实例即可访问静态方法。

使用类名调用静态方法。例如：MyClass.printMessage();

静态块

通过使用 static 关键字定义，用于在类加载时执行一次的初始化操作。静态代码块在类首次被加载时执行，并且在类中的其他静态成员之前执行。


public class test {
    public static void main(String[] args) {
        new People();
        new People();
    }
}
class People {
    static {
        System.out.println("静态代码块1-------------------------------");
    }
    static {
        System.out.println("静态代码块3-------------------------------");
    }
}

image.png

实例代码块

没有使用任何关键字定义，直接写在类中的代码块。实例代码块在创建对象时被调用，每次创建对象都会执行。通常用于在创建对象时进行一些通用的初始化操作。

public class test {
    public static void main(String[] args) {
        new People();
        new People();
    }
}
class People {
    {
        System.out.println("实例代码块2-------------------------------");
    }
}

image.png

静态代码块与实例代码的区别

public class test {
    public static void main(String[] args) {
        new People();
        new People();
    }
}
class People {
    static {
        System.out.println("静态代码块1-------------------------------");
    }
    {
        System.out.println("实例代码块2-------------------------------");
    }
    static {
        System.out.println("静态代码块3-------------------------------");
    }
}

image.png
可见:

  • 静态代码块优先级最高，只执行一次
  • 实例代码块优先级低，每次实例都执行

    构造方法

    构造方法是一种特殊的方法，用于创建并初始化对象。构造方法的名称必须与类名相同，并且没有返回类型。

    这和js类中的constructor是一致的

构造方法有以下特点：

  1. 构造方法在使用new关键字创建对象时被调用，且只调用一次。
  2. 构造方法可以有多个重载版本，即可以根据不同的参数列表创建不同的构造方法。
  3. 如果没有显式定义构造方法，Java会隐式地提供一个无参的默认构造方法，用于创建对象。
    public class test {
     
     
 public static void main(String[] args) {
     
     
     new People();
     new People();
 }
}
class People {
     
     
 People(){
     
     
     System.out.println("构造方法-------------------------------");
 }
}
    image.png

    构造方法与静态块的执行顺序

    public class test {
     
     
 public static void main(String[] args) {
     
     
     new People();
     new People();
 }
}
class People {
     
     
 static {
     
     
     System.out.println("静态代码块1-------------------------------");
 }
 {
     
     
     System.out.println("实例代码块2-------------------------------");
 }
 People(){
     
     
     System.out.println("构造方法-------------------------------");
 }
 static {
     
     
     System.out.println("静态代码块3-------------------------------");
 }
}
    image.png
    可见，优先级顺序 静态块 > 实例块 > 构造方法

继承

Java中的继承语法格式如下：

class Subclass extends Superclass {
   
   
    // 子类的方法和属性
}

其中，Subclass是子类，Superclass是父类。

我们看下面这个具体示例：

class Animal {
   
   
    public void eat() {
   
   
        System.out.println("Animal is eating");
    }
}

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

public class Test {
   
   
    public static void main(String args[]) {
   
   
        Dog d = new Dog();
        d.eat();   // 继承自Animal类
        d.bark();  // 继承自Dog类
    }
}

在上面的例子中，Dog类继承了Animal类。因此，Dog类可以使用Animal类中定义的eat()方法。同时，Dog类还定义了自己的bark()方法。

this关键字

如果上述Animal类需要一个入参来指定eat的内容，Animal类需要做一些更改

class Animal {
   
   
    String food;
    // 我们在构造方法中使用this改变了类的属性food的值
    public Animal(String food){
   
   
        this.food = food;
    }
    public void eat() {
   
   
        System.out.println("狗吃了" + this.food);
    }
}

this关键字可以用于访问当前类的成员变量和方法。

super

此时，Dog在继承Animal类时，也需要访问父类的成员变量food

class Dog extends Animal {
   
   
    public Dog(String food){
   
   
        // 使用super()可以调用父类的构造方法
        super(food);
    }
    public void bark() {
   
   
        System.out.println("Dog is barking");
    }
}

super关键字用于访问父类的成员变量和方法，super()必须是构造方法中的第一条语句

完整代码

public class Test {
   
   
    public static void main(String args[]) {
   
   
        Dog d = new Dog("火腿肠");
        d.eat();   // 继承自Animal类
        d.bark();  // 继承自Dog类
    }
}
class Animal {
   
   
    String food;
    public Animal(String food){
   
   
        this.food = food;
    }
    public void eat() {
   
   
        System.out.println("狗吃了" + this.food);
    }
}

class Dog extends Animal {
   
   
    public Dog(String food){
   
   
        super(food);
    }
    public void bark() {
   
   
        System.out.println("Dog is barking");
    }
}

多态

多态是面向对象编程中的一个重要特性，它允许一个对象在不同的上下文中表现出不同的行为。在Java中，多态性是通过继承和方法重写来实现的。
我们看一个示例：

class Animal {
   
   
   void name (){
   
   
      System.out.println("所有动物都有名字");
   }
}

class Dog extends Animal {
   
   
    void speak (){
   
   
        System.out.println("狗喜欢叫");
    }
}

上述代码中，我们定义了一个Animal类，Dog类继承了Animal类。
我们实例化一个Animal类，它的name方法自然可以执行。

public class Test {
   
   
    public static void main(String args[]) {
   
   
        Animal dw = new Animal();
        dw.name();
    }
}

image.png
现在，我们实例化一个Dog类，注意，Dog的实例有两种类型，Animal和Dog

public class Test {
   
   
    public static void main(String args[]) {
   
   
        Animal dw = new Animal();
        dw.name();
        Animal dog1 = new Dog();
        Dog dog2 = new Dog();
    }
}

Animal类型的dog1只有name方法，而Dog类型的dog2有speak和name方法

public class Test {
   
   
    public static void main(String args[]) {
   
   
        Animal dog1 = new Dog();
        dog1.name();
        Dog dog2 = new Dog();
        dog2.speak();
        dog2.name();
    }
}

这就是多态。多态是面向对象编程中的一个重要特性，它允许一个对象在不同的上下文中表现出不同的行为。在Java中，多态性是通过继承和方法重写来实现的。

重载

假设我们有一个登录方法，这个方法可以通过不同形式登录。如果我们在类中写两个完全一致的函数login名，会报错。
image.png

一个类中，不能重复声明相同的方法，相同的属性

我们也许会想到写一个login函数，通过if-else来实现逻辑。但是，在java中，使用函数重载，能更好的解决这个问题。
当我们给login函数定义不同的入参时，报错就取消了。
image.png

如果方法名相同，但是参数列表（个数、顺序、类型）不同，会认为是不同的方法。这个操作在JAVA中称之为方法的重载。

构造函数的重载

构造函数也是支持重载的

package top;

public class Test {
   
   
    public static void main(String args[]) {
   
   
        Login p1 = new Login();
        Login p2 = new Login("张三");
        Login p3 = new Login("张三","女");
    }
}
class Login {
   
   
    Login(){
   
   

    }
    Login(String name){
   
   

    }
    Login(String name,String sex){
   
   
        System.out.println(name + sex);
    }
}

image.png
此外，我们还可以借助this关键词来在构造函数中调用其他的重载函数

package top;

public class Test {
   
   
    public static void main(String args[]) {
   
   
        Login p1 = new Login();
    }
}
class Login {
   
   
    Login(){
   
   
        this("张三");
    }
    Login(String name){
   
   
        this(name,"女");
    }
    Login(String name,String sex){
   
   
        System.out.println(name + sex);
    }
}

image.png

文章标签：
Java
前端开发
JavaScript
存储
关键词：
Java类
前端java
Java面向对象编程
前端类
前端面向对象编程
石小石Orz
目录
相关文章
Naylor
|
14天前
|
存储 安全 Java
java.util的Collections类
Collections 类位于 java.util 包下，提供了许多有用的对象和方法，来简化java中集合的创建、处理和多线程管理。掌握此类将非常有助于提升开发效率和维护代码的简洁性，同时对于程序的稳定性和安全性有大有帮助。
Naylor
37 17
2G冲浪词条
|
6天前
|
安全 Java
Java多线程集合类
本文介绍了Java中线程安全的问题及解决方案。通过示例代码展示了使用`CopyOnWriteArrayList`、`CopyOnWriteArraySet`和`ConcurrentHashMap`来解决多线程环境下集合操作的线程安全问题。这些类通过不同的机制确保了线程安全，提高了并发性能。
2G冲浪词条
16 1
软件求生
|
10天前
|
存储 Java 程序员
Java基础的灵魂——Object类方法详解（社招面试不踩坑）
本文介绍了Java中`Object`类的几个重要方法，包括`toString`、`equals`、`hashCode`、`finalize`、`clone`、`getClass`、`notify`和`wait`。这些方法是面试中的常考点，掌握它们有助于理解Java对象的行为和实现多线程编程。作者通过具体示例和应用场景，详细解析了每个方法的作用和重写技巧，帮助读者更好地应对面试和技术开发。
软件求生
49 4
众所周知
|
11天前
|
Java 编译器 开发者
Java异常处理的最佳实践，涵盖理解异常类体系、选择合适的异常类型、提供详细异常信息、合理使用try-catch和finally语句、使用try-with-resources、记录异常信息等方面
本文探讨了Java异常处理的最佳实践，涵盖理解异常类体系、选择合适的异常类型、提供详细异常信息、合理使用try-catch和finally语句、使用try-with-resources、记录异常信息等方面，帮助开发者提高代码质量和程序的健壮性。
众所周知
26 2
java的细水长流
|
15天前
|
存储 安全 Java
如何保证 Java 类文件的安全性？
Java类文件的安全性可以通过多种方式保障，如使用数字签名验证类文件的完整性和来源，利用安全管理器和安全策略限制类文件的权限，以及通过加密技术保护类文件在传输过程中的安全。
java的细水长流
27 4
java的细水长流
|
19天前
|
Java 数据格式 索引
使用 Java 字节码工具检查类文件完整性的原理是什么
Java字节码工具通过解析和分析类文件的字节码，检查其结构和内容是否符合Java虚拟机规范，确保类文件的完整性和合法性，防止恶意代码或损坏的类文件影响程序运行。
java的细水长流
23 5
java的细水长流
|
19天前
|
Java API Maven
如何使用 Java 字节码工具检查类文件的完整性
本文介绍如何利用Java字节码工具来检测类文件的完整性和有效性，确保类文件未被篡改或损坏，适用于开发和维护阶段的代码质量控制。
java的细水长流
34 5
叫做饺子
|
19天前
|
存储 Java 编译器
java wrapper是什么类
【10月更文挑战第16天】
叫做饺子
22 3
mzlogin
|
21天前
|
Java 程序员 测试技术
Java｜让 JUnit4 测试类自动注入 logger 和被测 Service
本文介绍如何通过自定义 IDEA 的 JUnit4 Test Class 模板，实现生成测试类时自动注入 logger 和被测 Service。
mzlogin
21 5
东方睿赢
|
22天前
|
Java
在Java多线程编程中，实现Runnable接口通常优于继承Thread类
【10月更文挑战第20天】在Java多线程编程中，实现Runnable接口通常优于继承Thread类。原因包括：1) Java只支持单继承，实现接口不受此限制；2) Runnable接口便于代码复用和线程池管理；3) 分离任务与线程，提高灵活性。因此，实现Runnable接口是更佳选择。
东方睿赢
29 2

热门文章

最新文章

  • 1
    java Redis工具类
  • 2
    Java杂记9—NIO
  • 3
    Java——基于java自身包实现消息系统间的通信（TCP/IP+BIO）
  • 4
    java8 List根据对象中属性去重-多属性去重-去除重复字符串
  • 5
    Java接口签名(Signature)实现方案
  • 6
    Java的几种创建实例方法的性能对比
  • 7
    16.2. jps - Java Virtual Machine Process Status Tool
  • 8
    Java多线程初学者指南（9）：为什么要进行数据同步
  • 9
    Java 动态写轮眼 SharinganJPanel (整理)
  • 10
    Java项目导出源代码jar包在Eclipse中查看中文注释乱码的问题
  • 1
    前端后端测试接口mork神器，Apifox使用一分钟入门
    209
  • 2
    编译第三方前端项目时候出现Syntax Error: TypeError: Cannot set properties of undefined (setting ‘parent‘)
    467
  • 3
    【Web前端】CSS基本语法规范和引入方式&&常见选择器用法&&常见元素属性
    54
  • 4
    基于jeecg前端实现从表ERP格式选择
    34
  • 5
    前端进度条组件NProgress
    81
  • 6
    前端效果 登入界面
    49
  • 7
    vue前端展示【1】
    31
  • 8
    nvm,npm,yarn相关指令，前端配置准备
    54
  • 9
    深入浅出JVM（六）之前端编译过程与语法糖原理
    49
  • 10
    HTML5基础题及答案——必刷前端题目(背)
    58

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 基于ECS搭建Java Web开发环境
  • 使用Aliyun Java Intializr进行项目开发
  • 搭建Java Web开发环境
  • 部署基于Dragonwell的Java运行环境
  • 前端开发基础1：前端开发环境的安装和配置
    • 下一篇
    阿里云OSS设置跨域访问