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

简介: 【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

相关文章
|
2月前
|
Java 编译器 API
Java 密封类:精细化控制继承关系
Java 密封类:精细化控制继承关系
272 83
|
6天前
|
安全 Java 数据建模
Java记录类:简化数据载体的新选择
Java记录类:简化数据载体的新选择
158 101
|
6天前
|
安全 Java 开发者
Java记录类:简化数据载体的新方式
Java记录类:简化数据载体的新方式
158 100
|
1月前
|
安全 IDE Java
Java记录类型(Record):简化数据载体类
Java记录类型(Record):简化数据载体类
291 120
|
1月前
|
缓存 安全 Java
Java反射机制:动态操作类与对象
Java反射机制是运行时动态操作类与对象的强大工具,支持获取类信息、动态创建实例、调用方法、访问字段等。它在框架开发、依赖注入、动态代理等方面有广泛应用,但也存在性能开销和安全风险。本文详解反射核心API、实战案例及性能优化策略,助你掌握Java动态编程精髓。
|
1月前
|
存储 安全 Java
Java集合框架(一):List接口及其实现类剖析
本文深入解析Java中List集合的实现原理,涵盖ArrayList的动态数组机制、LinkedList的链表结构、Vector与Stack的线程安全性及其不推荐使用的原因,对比了不同实现的性能与适用场景,帮助开发者根据实际需求选择合适的List实现。
|
2月前
|
Java API
深入解析Java API中Object类的功能
了解和合理运用 Object类的这些方法,对于编写可靠和高效的Java应用程序至关重要。它们构成了Java对象行为的基础,影响着对象的创建、识别、表达和并发控制。
63 0
|
2月前
|
安全 Java
JAVA:Collections类的shuffle()方法
`Collections.shuffle()` 是 Java 中用于随机打乱列表顺序的工具方法,适用于洗牌、抽奖等场景。该方法直接修改原列表,支持自定义随机数生成器以实现可重现的打乱顺序。使用时需注意其原地修改特性及非线程安全性。
125 0
|
2月前
|
存储 Java 编译器
深入理解Java虚拟机--类文件结构
本内容介绍了Java虚拟机与Class文件的关系及其内部结构。Class文件是一种与语言无关的二进制格式,包含JVM指令集、符号表等信息。无论使用何种语言,只要能生成符合规范的Class文件,即可在JVM上运行。文章详细解析了Class文件的组成,包括魔数、版本号、常量池、访问标志、类索引、字段表、方法表和属性表等,并说明其在Java编译与运行过程中的作用。