Java类

已于 2024-04-20 11:08:21 修改
阅读量699 收藏 23
点赞数 29
文章标签： java
于 2024-04-20 11:07:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2303_76402248/article/details/137992875
版权

java类和对象

面向对象

  • java是一项面向对象的编程语言。
    • 对象是现实 word中的物体，比如：人，狗，汽车，电脑等。（对象是真实世界中物体在人脑中的映像， 包括实体对象和逻辑对象 ）
      • 对象的基本结构：属性（属性是描述对象特征的特征,就是类中的变量）
      • 对象的基本行为：方法（方法是描述对象行为的特征, 就是类中的方法[表示类具体化后可以做什么]）
      • 对象的基本特征：属性和方法（重中之重）

进行对象抽象

抽象：就是说在思想上把对象或现象之间的共同本质取出来而舍去别的个别非样本属性的思维方法。

  • 也就是说吧一系列相同或类似的实体对象的特点抽取出来，采用一个统一的表达方式来表示。
    • 举个例子：
      • 现在的对象是学生。
      • 找出学生这一对象的属性：

类

  • 把抽象出来的对象使用Java表示出来，那就是类class。
  • java中的对象是在java中一个类的实例化。

通俗的讲：类是一系列具有相同行为和特征的对象的集合。

对象是类的具体化,是类的实例化。

类是对象的模板。

类的定义：

举个例子：

  • 如果我们要研究的实体是学生这个群体，那么就可以创建一个类来表示学生这个群体。
  • 那什么是类的实例化那？：我们创建学生这个类的目的就是为了更高效的表示一个学生，通过类来表示实体中的一个对象这就是类的实例化。

学生类的定义：

  • 类的定义需要定义类的属性和方法。
    • 属性：学生的属性，如：姓名，年龄，性别，学号等。
    • 方法：学生的行为，例如：吃饭，睡觉，学习，运动等。
    • 这两个可以说成静态属性和动态属性。静态属性：姓名，年龄，性别，学号等。动态属性：吃饭，睡觉，学习，运动等。
      学生类的定义：
public class Student{
    // 属性：
    姓名;
    年龄;
    性别;
    学号;

    // 方法：
    吃饭;
    睡觉;
    学习;
    运动;
}

方法的定义

方法：方法就是一个代码块，用来执行特定的操作。在代码中当方法被调用时（可以理解成：当调用时，就是把方法中的代码放到了被调用处），方法就会执行，通常方法都会有返回值意思是方法执行之后的结果，可以没有返回值。

方法的定义：

修饰符 返回值类型 方法名(参数列表){
    // 方法体
    return 返回值;
}

若没有返回值,则返回值为void,表示没有返回值.

为了执行类的特定的行为，需要给类添加方法。因为有些属性是无法赋值，而是需要通过方法来表示。

属性的定义

属性：属性是描述对象特征的特征,就是类中的变量。

属性的定义：

修饰符 数据类型 属性名;

构造方法

构造方法：

类有一个特殊的成员方法叫做构造方法,它的作用是创建对象并初始化成员变量.

  • 构造方法定义规则
    java中的构造方法必须与该类具有相同的名字,并且没有方法返回值(包括没有void)。

另外,构造方法一般都应用public修饰符,这样才能在程序任意位置创建类的实例.

构造方法的定义：

修饰符 返回值类型 构造方法名(参数列表){
    // 方法体
    return 返回值;
}

注意: 每个类至少要有一个构造方法,如果不写一个构造方法,java语言将提供一个默认的该构造方法没有参数,而且方法体为空.

注意:如果一个类中已经定义了结构方法则系统不在提供默认的构造方法。

代码示例：通过学生这个实例。

// 创建一个学生类
public class Student {
    // 属性：
    // 定义属性
    String name;
    int age;
    String sex;
    String id;
    
    // 方法：
    // 定义方法
    public void study() {
        System.out.println("学习！");
    }

    public void eat() {
        System.out.println("吃饭！");
    }

    public void sleep() {
        System.out.println("睡觉！");
    }

    public void play() {
        System.out.println("运动！");
    }

    public static void main(String[] args) {
        // 创建两个对象
        Student s1 = new Student();
        Student s2 = new Student();
        System.out.println("第一个学生对象：");
        s1.name = "张三";
        s1.age = 18;
        s1.sex = "男";
        s1.id = "2019001";
        System.out.println("姓名：" + s1.name + "，年龄：" + s1.age + "，性别：" + s1.sex + "，学号：" + s1.id);
    
        System.out.println("第二个学生对象：");
        s2.name = "李四";
        s2.age = 19;
        s2.sex = "女";
        s2.id = "2019002";
        System.out.println("姓名：" + s2.name + "，年龄：" + s2.age + "，性别：" + s2.sex + "，学号：" + s2.id);
    
        // 调用方法
        s1.study();
        s1.eat();
        s1.sleep();
        s1.play();
        }
}

上面是类的定义,就是繁殖学生的模板

该类中存在一个无返回值的构造方法,用来初始化学生

下面就是具体的学生, 即实例化,就是创建对象.

  • 创建对象其本质就是创建一个XXX类型的变量,然后调用构造方法,初始化对象.
  • 基本的语法格式:
Student s = new Student();

  • 通过new关键字创建对象,然后调用构造方法,初始化对象.

  • 创建完对象之后,就可以进行一下操作来给类的属性赋值:

当然例子中的方法也是可以的。

s.setName("张三");
s.setAge(18);
s.setGender("男");

例子加上构造方法

public class Student{
    String name;
    int age;
    String sex;
    int id;

    // 无参数的构造方法
    public Student() {
        // 这里可以初始化属性
        // 例如：this.name = "张三";
    }

    // 有参数的构造方法
    public Student(String name, int age, String sex, int id) {
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.id = id;
        // 这里的初始化属性的初始值是null0
    }

    // 上面的两个构造方法就是对对象的初始化，
    // 也就是创建对象的时候，需要传递的参数

    public void study(){
        System.out.println("学习");
    }

    public void eat(){
        System.out.println("吃饭");
    }

    public void sleep(){
        System.out.println("睡觉");
    }

    public void play(){
        System.out.println("运动");
    }

    public static void main(String[] args) {
        Student s1 = new Student();
        System.out.println(s1.name + s1.age);
    }

}

代码中this关键子是引用当前对象，所以this.name就是引用当前对象的name属性。

  • 什么是当前对象那：在执行代码的对象实例。
  • 引用：引用就是把一个对象赋值给另一个对象。
    如果用构造方法来给类初始化成：姓名：张三，年龄：18，性别：男，学号：2019001，那么构造方法可以写成：
public class Student{
    String name;
    int age;
    String sex;
    int id;

    // 构造方法
    // 给属性只一个初始值
    public Student (){
        this.name = "张三";
        this.age = 18;
        this.sex = "男";
        this.id = 2019001;
    }

    public void study(){
        System.out.println("学习!");
    }

    public void eat(){
        System.out.println("吃饭!");
    }

    public void sleep(){
        System.out.println("睡觉!");
    }

    public void play(){
        System.out.println("运动!");
    }

    public static void main(String[] args) {
        Student s2 = new Student();
        System.out.println("姓名：" + s2.name + "年龄：" + s2.age);
        System.out.println("性别：" + s2.sex + "学号" + s2.id);
    }
}

面向对象三大特点

1.封装

封装：将对象内部的数据与对外部隐藏，对外部提供接口，对外部隐藏内部实现细节。

  • 封装是Java面向对象的特点的表现，分装是一种信息隐蔽技术。
  • 封装有两个含义：
    • 把对象的全部属性和全部服务结合在一起，形成不可分割的独立单位。
    • 尽可能隐藏对象的内部结构。
  • 简单的说，如果我们使用了封装技术的话，别人就只能用我们做出来的东西而看不见我们的这个东西的内部结构了。

类的封装是一种保护类属性和方法不被为不代码直接访问的机制。

封装的功能：

  • 隐藏对象的实现细节
  • 迫使用户使用一个界面访问数据
  • 使代码更好维护，方便调试

2.继承

继承：如果一个对象A继承自另一个对象B，就把这个A称为“B的子对象”，而把B称为“A的父对象”。继承可以使得子对象有父对象的各种属性和方法，而不需要再次编写相同的代码。在令子对象继承父对象的同时，可以重新定义某些属性，并重写某些方法，即覆盖父对象的原有属性和方法。

3.多态

多态：同一行为的多种不同表达，或者统一行为的多种不同实现。

举一个简单的例子：比如我们说“笔”这个对象，它就有很多不同的表达或实现，比如有钢笔，铅笔，圆珠笔等等。那么我说“请给我一支笔”，你给我钢笔，铅笔或者圆珠笔都可以，这里的“笔”这个对象就具备多态。

就是说一个对象在不同的前提下有不同的表现。

代码中如何提现这些特点那？

类的封装

// 类的封装
public class Student{
    private String name;
    private int age;
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return this.name;
    }
    public void setAge(int age){
        // 验证年龄是否合法
        if(age >= 0 && age <= 120){
            this.age = age;
        }else{
            System.out.println("年龄不合法");
        }
    }
    public int getAge(){
        return this.age;
    }
}

public class Main {
    public static void main(String[] args){
        Student s = new Student();
        s.setName("张三");
        s.setAge(18);
        System.out.println(s.getName() + " " + s.getAge());
        Student s1 = new Student();
        s1.setName("李四");
        s1.setAge(200);
        System.out.println(s1.getName() + " " + s1.getAge());
    }
}

类的封装：

  1. priavte：私有属性，只能在类的内部访问，不能在类的外部直接访问。
    • 这里的外部是类的外部，即在当前类之外的代码。包括：
      • 其他类：任何在当前类之外的类中的代码都被视为外部代码。
      • 外部方法：类的实例方法（非静态方法）和静态方法之外的代码。
  2. set 和 get：通过set 和 get 方法来设置和获取属性的值。
    1. set：设置属性的值。
    2. get：获取属性的值。
    • set 和 get方法通常是为了提供对private属性间接访问：
    1. Getter方法（通常命名为get+属性名）用于获取private属性的值。
    2. Setter方法（通常命名为set+属性名）用于设置private属性的值。

类的继承
就是在上面的基础上，再定义一个子类，子类继承父类，子类可以继承父类的属性和方法，子类还可以定义自己的属性和方法。
3. 基本语法：

public class 子类 extends 父类{
    //子类可以继承父类的属性和方法
}
  1. 示例：
public class Student1 extends Student {
    public static void main(String[] args) {
        Student1 s1 = new Student1();
        s1.setName("张三");
        s1.setAge(18);
        System.out.println(s1.getName() + " " + s1.getAge());
    }
}

继承：

在代码中，Student1类通过extends关键字继承自Student类。
- 这意味着Student1类可以使用Student类中的所有属性和方法，包括name和age，setName和setAge方法。这就体现了类的继承。

  • 注意：在创建继类之前，首先要创建一个具有共性的一般类，即父类，超类，基类。

之后在子类中可以添加自己特有的属性和方法。也可以覆盖父类的方法。（要注意：覆盖方法时，子类方法必须与父类方法一致，包括参数和返回值类型。）

例如：再创建一个Student2类，继承了Studnet类，并添加了score属性和setScore方法。

public class Student {
    private String name;
    private int age;

    // 构造方法
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 获取姓名
    public String getName() {
        return name;
    }

    // 获取年龄
    public int getAge() {
        return age;
    }

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

// 子类
public class HighSchoolStudent extends Student {
    private int grade;

    // 构造方法
    public HighSchoolStudent(String name, int age, int grade) {
        super(name, age);
        this.grade = grade;
    }

    // 重写父类方法
    @Override
    public void study() {
        System.out.println(getName() + "正在高中学习");
    }

    // 新方法
    public void attendExam() {
        System.out.println(getName() + "正在参加高中期末考试");
    }
}

// 测试类
public class Main {
    public static void main(String[] args) {
        HighSchoolStudent highSchoolStudent = new HighSchoolStudent("张三", 16, 11);
        
        // 调用继承自父类的方法
        System.out.println(highSchoolStudent.getName());
        System.out.println(highSchoolStudent.getAge());
        highSchoolStudent.study(); // 调用重写的方法
        
        // 调用子类自己的方法
        highSchoolStudent.attendExam();
    }
}

类的多态

java中，多态是一种允许对象通过同一个接口调用不同的对线的行为机制。

  • 多态主要是通过继承来实现的：多态有两种主要形式：
    • 方法重写：子类可以重写父类的方法，已提供与父类不同的行为。这种形式通过在子类中定义与父类相同签名的方法来实现的。当使用父类的引用调用方法时，实际调用的是子类中重写的方法，这是多态最常见的形式。
    1. 相同签名的方法：方法的名称和参数列表（即参数的数量，类型和顺序）完全相同的方法。子类中的方法与父类中的方法具有形同的签名时，子类可以重写父类中的方法。这样，子类可以提供与父类不同的方法实现，而调用时，实际调用的是子类中的方法。
    • 方法重载：虽然这与多态不完全相同，但是方法重载是通过在同一类中定义多个同名参数不同的方法来实现的。这些方法在编译时通过参数列表的不同进行区分。
// 父类
class Animal {
    public void makeSound() {
        System.out.println("动物发出声音");
    }
}

// 子类1
class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("狗发出汪汪声");
    }
}

// 子类2
class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("猫发出喵喵声");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal1 = new Dog(); // 创建 Dog 对象，但是用 Animal 类型引用它
        Animal animal2 = new Cat(); // 创建 Cat 对象，但是用 Animal 类型引用它
        
        animal1.makeSound(); // 调用的是 Dog 类中重写的 makeSound() 方法
        animal2.makeSound(); // 调用的是 Cat 类中重写的 makeSound() 方法
    }
}

在上面的例子中Animal是父类，Dog和Cat是它的两个子类。makeSound方法在父类中定义，在子类中被重写。在Main类的main方法中，我们创建了一个Dog对象和一个Cat对象，并将它们都用Animal类型的引用来引用。然后调用makeSound方法，我们可以看到输出了不同的声音，这展示了类的多态。

@Override：java中的注释，用于告诉编辑器，当前的方法是在子类中重写了父类的方法。

包

包：在java中，包是类，接口或其他包的集合，包主要用来将类组织起来成为组，从而对类进行管理。

  • 包能干什么：
  1. 包允许你将包含类的代码的文件组织起来，易于查找和使用适当的类。
  2. 包不止是包含类和接口，还能够包含其他包，形成层次的包空间。
  3. 它有助于避免命名冲突。当使用很多类时，确保类和方法名称的唯一性是非常困难的。包能够形成层次命名空间，缩小了名称冲突的可能性，易于管理名称。
  • 为便于管理数目众多的类，Java语言引入了“包”的概念，可以说是对定义的Java类进行“分组”，将多个功能相关的类定义到一个“包”中，以解决命名冲突，引用不方便，安全性等问题。

简而言之：从逻辑上讲，包是一组相关类的集合；从物理上讲，同包即同目录。

JDK中常用的包

  1. java.lang包：包含一些Java语言的核心类，包含构成Java语言设计基础的类。
  • 此包中定义的最重要的一个类是Object类，代表类层次的根，Java是一个单根系统，最终的根就是Object类。
  • 此包中比较常用的类：
    • Math——封装最常用的数学方法，如正弦，余弦和平方根。
    • Strign, StringBuffer——封装常用的字符串操作
  • 平时不必导入该包，该Java包通常已经被导入。
  1. java.awt：包含了构成抽象窗口工具集的多个类，这些类被用来构建和管理应用程序的图形用户界面（GUI）。
  2. javax.swing：完全Java版的图形用户界面（GUI）解决方案，提供了很多完备的组件，可以应对复杂的桌面系统构建。
  3. java.net：包含执行与网络相关的操作的类，如URL，Socket，ServerSocket等。
  4. java.util：包含一些实用工具类，如定义系统特性，使用与日期日历相关的方法。还有重要的集合框架。
艾勒姆
关注
java类的执行步骤
sharesb的博客
03-08 2092
1.加载，生成某类对应的java.lang.class对象 2.链接，将加载的类的二进制代码合并到 JVM中，为静态变量声明内存空间 3.初始化，执行类的构造器（不是对象的构造器），为静态变量赋值，并执行静态代码块（静态代码块和静态变量赋值，谁在前面就先执行谁，如下） （初始化是这样的：使用cinit方法，将静态变量、静态方法放到一起，然后一起赋值，执行） package com.reflection; import com.sun.org.apache.bcel.internal.generi
java 类可见性_Java学习笔记(类的可见性)
weixin_35462155的博客
02-19 3347
1)类的可见性:public;友好的(无关键字);protected;private;public:公开类,在包内,包外都可见,是可见性级别最高的;友好的:也是默认的安全级别,包外不可见,包内可见.用在内部类同protected级别相同.protected:保护级,只能用于内部类.对类及子类(包内子类，包外子类不可见)和包内其它类可见.private:私有级，只能用于内部类，只对类本身可见。类的可...
java中类何时被加载_java类在何时被加载
weixin_30233335的博客
02-19 4126
我们接着上一章的代码继续来了解一下java类是在什么时候加载的。在开始验证之前，我们现在IDEA做如下配置。-XX:+TraceClassLoading 监控类的加载我们新建了一个TestController 来测试类的加载时机，代码如下：@RestControllerpublic class TestController {@RequestMapping("/newInstance")publi...
【idea系列】插件之JSON 转 java 类
檀越的博客
08-31 1万+
RoboPOJOGenerator 是一款 idea 插件，用于自动生成 Java 类的 POJO（Plain Old Java Object）代码，可以帮助开发者快速生成 Java 类，从而提高编程效率。
Java类的私有属性和封装的理解
Java非常实用博客
10-20 3086
新手在用框架进行开发的时候，速成了框架，却往往忽略了一些基础，比如写实体类的时候，常写Setter和Getter方法，它们的作用是什么呢？有没有注意过类的属性都是private修饰的呢？ 抛开这些，先看一个例子，理解一下private吧： //没有实现set和get方法的实体类 public class Target { public String name; private int age;//私有属性 } private关键字的作用 被private修饰的属性，只能在本
根据json数据体快速生成规范的java类
weixin_41501825的博客
06-21 2787
根据json数据体快速生成规范的java类，符合小驼峰的命名规范，生成对应JsonAlias的注解~~
Java类的加载、链接和初始化
关于代码的那些事
07-14 2145
Java字节代码的表现形式是字节数组（byte[]），而Java类在JVM中的表现形式是java.lang.Class类 的对象。一个Java类从字节代码到能够在JVM中被使用，需要经过加载、链接和初始化这三个步骤。这三个步骤中，对开发人员直接可见的是Java类的加 载，通过使用Java类加载器（class loader）可以在运行时刻动态的加载一个Java类；而链接和初始化则是在使用Java
深入理解Java类加载器(一)：Java类加载原理解析
热门推荐
Rico's Blogs
05-15 6万+
每个开发人员对java.lang.ClassNotFoundExcetpion这个异常肯定都不陌生，这个异常背后涉及到的是Java技术体系中的类加载机制。本文简述了JVM三种预定义类加载器，即启动类加载器、扩展类加载器和系统类加载器，并介绍和分析它们之间的关系和类加载所采用的双亲委派机制，给出并分析了与Java类加载原理相关的若干问题。
Java类加载器分类
✨ 欢迎来到【Seal ^_^ 的CSDN博客】！这里是我记录技术心得、分享经验的地方。✨
07-25 5713
Java的类加载器是负责将类的二进制数据加载到JVM中的关键组件。主要存在以下三种类加载器：
java类内部的方法名称可以相同吗？
m0_58680865的博客
05-07 3249
答：java类内部的方法名称可以相同。 原因： java的一个特性是“多态性”。多态性包括两种： ①类内部多态(重载)。 ②继承中多态(覆写)。 类内部的多态：在一个类的内部如果有多个方法的方法名相同参数列表不同。 由类内部多态的定义可知，同一个类中，可以出现相同名称的方法，但是参数列表一定要不同。其中最典型的就是有参和无参的构造方法。 实体类中有参和无参的构造方法： //无参构造方法 public Animal() { } //无参构造方法 public Animal
《kettle中调用java类》示例代码
10-12
Kettle提供了丰富的转换和作业元素，能够处理各种数据源和目标，其中就包括对Java类的调用。在标题《kettle中调用java类》示例代码中，我们关注的是如何在Kettle的转换或作业中嵌入Java代码，以实现更复杂的数据处理...
Delphi调用Java类（支持Java 6）完整源代码，可直接调试运行
03-14
通过测试，Delphi的RSA算法无法与Java的RSA算法兼容，经过各种周折最终尝试了Delphi调用Java的类的方法进行RSA加密解密；这是非常令人振奋的解决方案，但是前期也遇到不少问题。 在网上找到...
【Java基础知识 25】Java类加载与初始化
学Java，找哪吒
11-25 4984
将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的java.lang.class对象。
【JAVA开源】基于Vue和SpringBoot的高校学科竞赛平台
杨荧的CSDN博客
10-10 1472
教师功能有个人中心，题目类型管理，竞赛题库管理，竞赛类型管理，竞赛信息管理，报名信息管理，竞赛评分管理，参赛名单管理，晋级名单管理，获奖名单管理，竞赛总结管理，报销清单管理，成绩申诉管理，参赛信息管理，参赛信息管理，往年成绩管理，获奖情况管理。
【C++刷题】力扣-#121-买卖股票的最佳时机
最新发布
会写代码的饭桶
10-16 276
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 329
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
Springboot api http并发测试请求
nsa65223的专栏
10-11 295
【代码】Springboot api http并发测试请求。
spring task的使用场景
qq_40603125的博客
10-13 302
spring任务调度框架约定的时间。
2024.10月12日--- SpringMVC异常处理
whisper_Java 的博客
10-12 946
*** 用户【】 IP[]* 在【时间】* 操作【Controller.find】 发生如下异常*/@OverrideSystem.out.println("---------执行了自定义异常处理器------------");// 根据不同的异常类型，设置不同的响应状态码// 可以添加更多的自定义处理逻辑//}else {// 记录日志或其他处理逻辑// 可以将异常信息放入模型中供视图展示。
Java类包详解与应用指南
Java类包的使用对于编写清晰、可维护的代码至关重要。以下是对部分Java类包的详细介绍： 1. **java.applet** - 这个包包含了创建和运行Applet所需的基本类和接口。Applet是嵌入在Web页面中的小型Java程序，可以在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值