首页 > 编程语言 >Java从入门到精通-类和对象（三）

Java从入门到精通-类和对象（三）

时间：2023-09-14 16:02:09浏览次数：47  
标签：精通 Java 入门 构造方法 对象 创建 String public 变量

1.6实践与练习

Java从入门到精通-类和对象（三）_初始化

1.1 面向对象概述

基础练习题：

1.创建一个类Person，具有姓名和年龄两个成员变量，以及一个方法displayInfo()用于显示姓名和年龄。然后创建一个Person对象并调用displayInfo()方法。

public class Person {
    // 成员变量
    private String name;
    private int age;

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

    // 成员方法用于显示姓名和年龄
    public void displayInfo() {
        System.out.println("姓名: " + name);
        System.out.println("年龄: " + age);
    }

    public static void main(String[] args) {
        // 创建Person对象并初始化
        Person person1 = new Person("Alice", 25);

        // 调用displayInfo()方法来显示信息
        System.out.println("个人信息：");
        person1.displayInfo();
    }
}

代码释义：

  1. 我们创建了一个名为Person的类，该类具有两个成员变量name（姓名）和age（年龄）。
  2. 在构造方法中，我们接受两个参数，用于初始化成员变量name和age。
  3. 类中有一个名为displayInfo()的成员方法，它用于显示姓名和年龄。
  4. 在main方法中，我们创建了一个Person对象person1，并通过构造方法初始化了该对象的姓名和年龄。
  5. 最后，我们调用person1对象的displayInfo()方法，显示了姓名和年龄信息。

代码总结：

在这个示例中，我们创建了一个Person类，演示了如何定义成员变量、构造方法和成员方法。通过创建一个Person对象，并调用displayInfo()方法，我们成功地显示了对象的姓名和年龄信息。这个示例帮助您理解了类和对象的基本概念，以及如何使用它们来组织和操作数据。

综合练习题：

2.创建一个类Rectangle，具有长度和宽度两个成员变量，以及一个方法calculateArea()用于计算矩形的面积。然后创建多个Rectangle对象，并计算它们的面积。

public class Rectangle {
    // 成员变量
    private double length;
    private double width;

    // 构造方法
    public Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }

    // 计算矩形的面积
    public double calculateArea() {
        return length * width;
    }

    public static void main(String[] args) {
        // 创建多个Rectangle对象并初始化
        Rectangle rectangle1 = new Rectangle(5.0, 4.0);
        Rectangle rectangle2 = new Rectangle(3.0, 7.0);
        Rectangle rectangle3 = new Rectangle(6.0, 2.5);

        // 计算并打印矩形的面积
        System.out.println("矩形1的面积：" + rectangle1.calculateArea());
        System.out.println("矩形2的面积：" + rectangle2.calculateArea());
        System.out.println("矩形3的面积：" + rectangle3.calculateArea());
    }
}

代码释义：

  1. 我们创建了一个名为Rectangle的类，该类有两个成员变量length（长度）和width（宽度）。
  2. 在构造方法中，我们接受两个参数，用于初始化成员变量length和width。
  3. 类中有一个名为calculateArea()的成员方法，用于计算矩形的面积，即length * width。
  4. 在main方法中，我们创建了三个Rectangle对象，并通过构造方法初始化了它们的长度和宽度。
  5. 最后，我们调用每个矩形对象的calculateArea()方法来计算并打印矩形的面积。

代码总结：

这个示例演示了如何创建一个Rectangle类，定义成员变量和方法，以及如何创建多个对象并使用它们的方法来计算矩形的面积。这有助于理解如何在面向对象编程中使用类和对象来组织和操作数据。

1.2 类

基础练习题：

3.创建一个类Car，具有品牌和型号两个成员变量，以及一个方法startEngine()用于启动汽车引擎。然后创建一个Car对象并调用startEngine()方法。

public class Car {
    // 成员变量
    private String brand;
    private String model;

    // 构造方法
    public Car(String brand, String model) {
        this.brand = brand;
        this.model = model;
    }

    // 启动汽车引擎
    public void startEngine() {
        System.out.println("启动" + brand + " " + model + "的引擎");
    }

    public static void main(String[] args) {
        // 创建Car对象并初始化
        Car myCar = new Car("Toyota", "Camry");

        // 调用startEngine()方法来启动汽车引擎
        myCar.startEngine();
    }
}

代码释义：

  1. 创建一个名为Car的类，该类有两个成员变量brand（品牌）和model（型号）。
  2. 在构造方法中，接受两个参数，用于初始化成员变量brand和model。
  3. 类中有一个名为startEngine()的成员方法，用于启动汽车引擎，并在控制台上显示启动信息。
  4. 在main方法中，创建一个Car对象myCar，并通过构造方法初始化了它的品牌和型号。
  5. 最后，调用myCar对象的startEngine()方法来启动汽车引擎。

代码总结：

示例演示了如何创建一个Car类，定义成员变量和方法，以及如何创建一个对象并调用其方法来执行操作。这有助于理解如何在面向对象编程中使用类和对象来模拟真实世界的实体和行为。

综合练习题：

4.创建一个类Circle，具有半径成员变量和一个方法calculateArea()用于计算圆的面积。然后创建多个Circle对象，并计算它们的面积。

public class Circle {
    // 成员变量
    private double radius;

    // 构造方法
    public Circle(double radius) {
        this.radius = radius;
    }

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

    public static void main(String[] args) {
        // 创建多个Circle对象并初始化
        Circle circle1 = new Circle(3.0);
        Circle circle2 = new Circle(5.0);
        Circle circle3 = new Circle(2.5);

        // 计算并打印圆的面积
        System.out.println("圆1的面积：" + circle1.calculateArea());
        System.out.println("圆2的面积：" + circle2.calculateArea());
        System.out.println("圆3的面积：" + circle3.calculateArea());
    }
}

代码释义：

  1. 创建一个名为Circle的类，该类有一个成员变量radius（半径）。
  2. 在构造方法中，接受一个参数，用于初始化成员变量radius。
  3. 类中有一个名为calculateArea()的成员方法，用于计算圆的面积，即Math.PI * radius * radius。
  4. 在main方法中，创建三个Circle对象，分别代表不同半径的圆，并通过构造方法初始化它们的半径。
  5. 最后，调用每个圆对象的calculateArea()方法来计算并打印圆的面积。

代码总结：

示例演示了如何创建一个Circle类，定义成员变量和方法，以及如何创建多个对象并调用其方法来执行操作。这有助于理解如何在面向对象编程中使用类和对象来模拟真实世界的实体和行为。

1.3 类的构造方法

基础练习题：

4.创建一个类Book，具有书名和作者两个成员变量，以及一个带参数的构造方法用于初始化这两个成员变量。然后创建多个Book对象，并初始化它们的属性。

public class Book {
    // 成员变量
    private String title;
    private String author;

    // 带参数的构造方法
    public Book(String title, String author) {
        this.title = title;
        this.author = author;
    }

    public static void main(String[] args) {
        // 创建多个Book对象并初始化
        Book book1 = new Book("Java Programming", "John Smith");
        Book book2 = new Book("Python Basics", "Alice Johnson");
        Book book3 = new Book("C++ Fundamentals", "David Brown");

        // 打印书籍信息
        System.out.println("书籍1：" + book1.title + "，作者：" + book1.author);
        System.out.println("书籍2：" + book2.title + "，作者：" + book2.author);
        System.out.println("书籍3：" + book3.title + "，作者：" + book3.author);
    }
}

代码释义：

  1. 创建一个名为Book的类，该类有两个成员变量title（书名）和author（作者）。
  2. 在构造方法中，接受两个参数，用于初始化成员变量title和author。
  3. 在main方法中，创建三个Book对象，每个对象代表一本书，并通过构造方法初始化了它们的书名和作者。
  4. 最后，打印每本书的信息，包括书名和作者。

代码总结：

示例演示了如何创建一个Book类，定义成员变量和带参数的构造方法，以及如何创建多个对象并初始化它们的属性。这有助于理解如何在面向对象编程中使用类和对象来模拟真实世界的实体和行为。

综合练习题：

  1. 创建一个类Employee，具有姓名、工号和薪水三个成员变量，以及一个带参数的构造方法用于初始化这些成员变量。然后创建多个Employee对象，并初始化它们的属性。
public class Employee {
    // 成员变量
    private String name;
    private int employeeId;
    private double salary;

    // 带参数的构造方法
    public Employee(String name, int employeeId, double salary) {
        this.name = name;
        this.employeeId = employeeId;
        this.salary = salary;
    }

    public static void main(String[] args) {
        // 创建多个Employee对象并初始化
        Employee employee1 = new Employee("John Smith", 101, 50000.0);
        Employee employee2 = new Employee("Alice Johnson", 102, 60000.0);
        Employee employee3 = new Employee("David Brown", 103, 55000.0);

        // 打印员工信息
        System.out.println("员工1：" + employee1.name + "，工号：" + employee1.employeeId + "，薪水：" + employee1.salary);
        System.out.println("员工2：" + employee2.name + "，工号：" + employee2.employeeId + "，薪水：" + employee2.salary);
        System.out.println("员工3：" + employee3.name + "，工号：" + employee3.employeeId + "，薪水：" + employee3.salary);
    }
}

代码释义：

  1. 创建一个名为Employee的类，该类有三个成员变量name（姓名）、employeeId（工号）和salary（薪水）。
  2. 在构造方法中，接受三个参数，用于初始化成员变量name、employeeId和salary。
  3. 在main方法中，创建三个Employee对象，每个对象代表一个员工，并通过构造方法初始化了他们的姓名、工号和薪水。
  4. 最后，打印每个员工的信息，包括姓名、工号和薪水。

代码总结：

示例演示了如何创建一个Employee类，定义成员变量和带参数的构造方法，以及如何创建多个对象并初始化它们的属性。这有助于理解如何在面向对象编程中使用类和对象来模拟真实世界的实体和行为。

1.4 静态变量和静态方法

基础练习题：

7.创建一个类MathOperations，具有静态方法add()和subtract()，用于执行加法和减法操作。然后在main方法中调用这些静态方法。

public class MathOperations {
    // 静态方法：加法
    public static int add(int a, int b) {
        return a + b;
    }

    // 静态方法：减法
    public static int subtract(int a, int b) {
        return a - b;
    }

    public static void main(String[] args) {
        // 调用add()方法进行加法操作
        int sum = MathOperations.add(10, 5);
        System.out.println("10 + 5 = " + sum);

        // 调用subtract()方法进行减法操作
        int difference = MathOperations.subtract(20, 8);
        System.out.println("20 - 8 = " + difference);
    }
}

代码释义：

  1. 创建一个名为MathOperations的类，该类具有两个静态方法：add()用于加法操作，subtract()用于减法操作。
  2. 静态方法add()接受两个整数参数a和b，执行加法并返回结果。
  3. 静态方法subtract()接受两个整数参数a和b，执行减法并返回结果。
  4. 在main方法中，调用了MathOperations类的静态方法add()和subtract()来执行加法和减法操作，并将结果打印到控制台。

代码总结：

示例演示了如何创建一个MathOperations类，定义静态方法来执行加法和减法操作，以及如何在main方法中调用这些静态方法。静态方法可以在不创建对象的情况下使用，用于执行通用的操作。这有助于理解如何使用静态方法来组织和执行代码。

综合练习题：

7.创建一个类Product，具有商品名称、价格和库存数量三个成员变量，以及静态变量totalProducts用于跟踪总商品数量。编写构造方法来初始化成员变量，并在每次创建新对象时更新totalProducts。

public class Product {
    // 成员变量
    private String productName;
    private double price;
    private int quantity;

    // 静态变量：总商品数量
    private static int totalProducts = 0;

    // 带参数的构造方法
    public Product(String productName, double price, int quantity) {
        this.productName = productName;
        this.price = price;
        this.quantity = quantity;
        totalProducts++; // 每次创建新对象时更新总商品数量
    }

    public static void main(String[] args) {
        // 创建多个Product对象并初始化
        Product product1 = new Product("Laptop", 899.99, 10);
        Product product2 = new Product("Smartphone", 499.99, 20);

        // 打印商品信息和总商品数量
        System.out.println("商品1：" + product1.productName + "，价格：" + product1.price + "，库存数量：" + product1.quantity);
        System.out.println("商品2：" + product2.productName + "，价格：" + product2.price + "，库存数量：" + product2.quantity);

        System.out.println("总商品数量：" + Product.totalProducts);
    }
}

代码释义：

  1. 创建一个名为Product的类，该类有三个成员变量productName（商品名称）、price（价格）和quantity（库存数量）。
  2. 静态变量totalProducts用于跟踪总商品数量，并在每次创建新对象时更新。
  3. 带参数的构造方法接受商品名称、价格和库存数量，用于初始化成员变量，并在构造方法中递增totalProducts来更新总商品数量。
  4. 在main方法中，我们创建了两个Product对象，每个对象代表一种商品，并通过构造方法初始化它们的属性。
  5. 最后，打印每种商品的信息和总商品数量。

代码总结：

示例演示了如何创建一个Product类，定义成员变量和静态变量，以及如何在构造方法中更新静态变量以跟踪总商品数量。这有助于理解如何使用静态变量来共享数据和状态。

综合练习题：

设计一个简单的学生管理系统，包括以下要求：

  1. 创建一个Student类，包括学生的姓名、年龄和成绩作为成员变量。
  2. 为Student类创建构造方法，用于初始化学生的姓名、年龄和成绩。
  3. 创建一个School类，用于管理学生信息。School类应该包括一个存储学生对象的数组（或集合）。
  4. School类应该提供以下功能：
  • 添加学生：能够向学校中添加新的学生信息。
  • 查找学生：能够根据学生的姓名查找学生信息并显示。
  • 显示所有学生信息：能够列出学校中所有学生的姓名、年龄和成绩。
  1. 在main方法中，创建一个School对象，并模拟添加多个学生信息，然后测试查找学生和显示所有学生信息的功能。

提示：

  • 需要创建Student类和School类，以及适当的成员变量和方法。
  • 使用数组或集合来存储学生信息。
  • 在main方法中，创建School对象并模拟添加学生信息，然后测试您的功能。
import java.util.ArrayList;

// 学生类
class Student {
    private String name;
    private int age;
    private double score;

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

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

    // 显示学生信息
    public void displayInfo() {
        System.out.println("姓名: " + name + ", 年龄: " + age + ", 成绩: " + score);
    }
}

// 学校类
class School {
    private ArrayList<Student> students = new ArrayList<>();

    // 添加学生
    public void addStudent(Student student) {
        students.add(student);
    }

    // 查找学生
    public Student findStudentByName(String name) {
        for (Student student : students) {
            if (student.getName().equals(name)) {
                return student;
            }
        }
        return null; // 如果找不到返回null
    }

    // 显示所有学生信息
    public void displayAllStudents() {
        System.out.println("学校所有学生信息：");
        for (Student student : students) {
            student.displayInfo();
        }
    }
}

public class StudentManagementSystem {
    public static void main(String[] args) {
        // 创建学校对象
        School school = new School();

        // 模拟添加学生信息
        school.addStudent(new Student("Alice", 18, 95.5));
        school.addStudent(new Student("Bob", 19, 88.0));
        school.addStudent(new Student("Charlie", 20, 92.5));

        // 测试查找学生和显示所有学生信息功能
        Student foundStudent = school.findStudentByName("Bob");
        if (foundStudent != null) {
            System.out.println("查找到的学生信息：");
            foundStudent.displayInfo();
        } else {
            System.out.println("未找到该学生！");
        }

        school.displayAllStudents();
    }
}

解释：

  1. 创建了一个Student类，其中包括学生的姓名、年龄和成绩作为成员变量，并提供了构造方法和显示学生信息的方法。
  2. 创建了一个School类，该类使用ArrayList来存储学生对象，并提供了添加学生、查找学生和显示所有学生信息的方法。
  3. 在main方法中，我们创建了一个School对象，并模拟添加了多个学生信息。然后，我们测试了查找学生和显示所有学生信息的功能。

标签：精通,Java,入门,构造方法,对象,创建,String,public,变量
From： https://blog.51cto.com/u_15747017/7470928

相关文章

  • 拼多多面试题解析：Java实现继承的七种方式！
    大家好，我是小米！今天，我要和大家一起来深入探讨一下拼多多的面试题：Java实现继承有哪7种方式？这是一个相当有深度的问题，不过别担心，我会尽力以通俗易懂的方式给大家讲解清楚，让大家对Java继承有更深刻的理解。什么是继承在Java编程中，继承是一种非常重要的概念，它允许一个类（子类/派......
  • java架构师主要是干什么的，要注意什么？
    Java架构师当然是专注于Java开发架构设计的工程师。这里包含两层意思：1、Java架构师限定了工程师的专业范围，专注于Java开发；2、Java架构师明确了工作职责，主要从事Java架构设计。如果往深一层探讨，则需要明白，什么是Java开发，Java架构师的主要职责是什么？什么是JavaJava是一种程序......
  • Java进阶学习之Java架构师的学习路线
    Java架构师，首先要是一个高级Java攻城狮，熟练使用各种框架，并知道它们实现的原理。Java架构师的作用就是要满足业务需求，用低的硬件网络成本和技术维护成本。Java架构师还要根据业务发展阶段，提前预见发展到下一个阶段系统架构的解决方案，并且设计当前架构时将架构的升级扩展考虑进去，做......
  • 怎么成为一名Java架构师 都需要掌握哪些技术
    怎么成为一名Java架构师？都需要掌握哪些技术？Java架构师，首先要是一个高级Java攻城狮，熟练使用各种框架，并知道它们实现的原理。jvm虚拟机原理、调优，懂得jvm能让你写出性能更好的代码;池技术，什么对象池，连接池，线程池……Java构架师需要掌握的技术：1、熟练使用各种框架，并知道它们实现......
  • 【Java框架】Java十大常用框架介绍
     一、SpringMVCSpringWebMVC是一种基于Java的实现了WebMVC设计模式的请求驱动类型的轻量级Web框架，即使用了MVC架构模式的思想，将web层进行职责解耦，基于请求驱动指的就是使用请求-响应模型，框架的目的就是帮助我们简化开发，SpringWebMVC也是要简化我们日常Web开发的。模型（M......
  • Java反序列化：CommonsCollections7调试分析
    CommonsCollections7基础知识1.HashTable散列表，也称为哈希表，以key-value形式进行访问的数据结构HashTable具有线程安全：多个线程同时访问它时，不会导致数据不一致。相对于HashMap、ConcurrentHashMap等线程安全性散列表，HashTable比较古老诸如散列表，常见的类方法：putget......
  • python-docx -快速入门
    docx​ python-docx是一个用于创建和更新Microsoftword(.docx)文件的Python库安装pipinstallpython-docx快速入门打开文档需要的第一件事是要处理的文档。fromdocximportDocumentdocument=Document()这将打开一个基于默认"模板"的空白文档，这与你使用内置默认......
  • JAVA架构与开发（JAVA架构是需要考虑的几个问题）
       在企业中JAVA架构师主要负责企业项目技术架构，企业技术战略制定，技术框架搭建，技术培训和技术攻坚的工作。   在JAVA领域，比较多的都是web项目。用于解决企业的数字化转型。对于JAVA架构师而言，平时对项目的架构主要考虑这几个方面的问题。 一、项目的业务架构：包......
  • java架构师是做什么的 java架构师的工作内容
    Java架构师每天的工作是什么？Java架构师估计是每个java程序员都向往的职位吧，不过成为java架构师是需要经历漫长修炼的，不过我们可以先了解一下Java架构师每天的工作内容，感兴趣的小伙伴不妨看看吧。 java架构师是做什么的java架构师的工作内容1.负责设计和建设软件系统架构(平台......
  • java中有哪些并发的List?只知道一种的就太逊了
    java中有很多list，但是原生支持并发的并不多，我们在多线程的环境中如果想同时操作同一个list的时候，就涉及到了一个并发的过程，这时候我们就需要选择自带有并发属性的list，那么java中的并发list到底有哪些呢？今天要给大家介绍的是ArrayList、CopyOnWriteArrayList、ConcurrentLinkedDeque......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99