JAVA第三次作业

最新推荐文章于 2022-03-21 09:49:38 发布

weixin_30896511

最新推荐文章于 2022-03-21 09:49:38 发布

阅读量194

点赞数

CC 4.0 BY-SA版权

文章标签： java 设计模式数据库

原文链接：http://www.cnblogs.com/yamito/p/6663956.html

本文主要介绍了Java面向对象编程的基本概念和技术，包括封装性、单例设计模式的应用、参数传递机制的理解等内容，并通过具体案例详细讲解了类的设计、常用方法的实现及面向对象编程思想的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

（一）学习总结

1.什么是面向对象的封装性，Java中是如何实现封装性的？试举例说明。

java中的封装可以通过private指令来实现，被封装的属性只能够在包含这个属性的类或方法的内部进行调用，外部如果想要查看该属性需通过其他方法来实现。
例如在Person类中有一个name属性没有经过封装，我们可以在这个类的外部直接调用。

class Person{
    String name="张三";
}
public class Demo{
    public static void main(String args[]){
        Person per=new Person();
        System.out.println(per.name);   
    }
}

如果这是个人信息就会有泄漏的隐患，经过private封装后的name，不能够被外部直接调用，但可以通过在类中加入新的方法（getter）来实现。

class Person{
    private String name="张三";
    public String getName(){
        return this.name;
    }
}
public class Demo{
    public static void main(String args[]){
        Person per=new Person();
        System.out.println(per.getName());  
    }
}

在实现原有功能的基础上，使用封装能够使模块具有更高的内聚性（???），也便于以后的维护。

2.阅读下面程序，分析是否能编译通过？如果不能，说明原因。

(1)

class A{
    private int secret = 5;
}
public class Test{
    public static void main(String args[]){
        A a = new A();
        System.out.println(a.secret++);
    }
}

不能通过，secret被封装过，在外部引用需要用方法来实现

class A{
    private int secret = 5;
    public int getSecret(){
        return this.secret;
    }
}
public class Test{
    public static void main(String args[]){
        A a = new A();
        int secret=a.getSecret();
        System.out.println(secret++);
    }
}

(2)

public class Test{
    int x = 50;
    static int y = 200;
    public static void method(){
        System.out.println(x+y);
    }
    public static void main(String args[]){
        Test.method();
    }
}

不能通过，静态变量只能在静态方法中使用，同样，非静态变量不能在静态方法中使用，把变量x也改为静态变量即可。

public class Test{
    static int x = 50;
    static int y = 200;
    public static void method(){
        System.out.println(x+y);
    }
    public static void main(String args[]){
        Test.method();
    }
}

3 . 使用类的静态变量和构造方法，可以跟踪某个类创建的对象个数。声明一个图书类，数据成员为编号，书名，书价，并拥有静态数据成员册数记录图书的总数。图书编号从1000开始，每产生一个对象，则编号自动递增（利用静态变量和构造方法实现）。下面给出了测试类代码和Book类的部分代码，将代码补充完整。

class Book{
    int bookId;
    String bookName;
    double price;
    // 声明静态变量
    
    //定义静态代码块对静态变量初始化
    
    //构造方法
    
     public String getBookName() {
        return bookName;
    }
    public void setBookName(String bookName) {
        this.bookName = bookName;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }  
    //定义方法求图书总册数
    
    //重写toString方法
    
}
public class Test{
    public static void main(String args[]){ 
        Book[] books = {new Book("c语言程序设计",29.3),
                        new Book("数据库原理",30),
                        new Book("Java学习笔记",68)};
        System.out.println("图书总数为："+ Book.totalBook()); 
        for(Book book:books){
            System.out.println(book.toString());
        }
    }   
}

补全后：

class Book{
    int bookId;
    String bookName;
    double price;
    static int bookNumber;// 声明静态变量
    
    static{     //定义静态代码块对静态变量初始化
        bookNumber=1000;
    }
    
    public Book(String bookName,double price){      //构造方法
        this.bookName=bookName;
        this.price=price;
        bookId=bookNumber;
        bookNumber++;
    }
     public String getBookName() {
        return bookName;
    }
    public void setBookName(String bookName) {
        this.bookName = bookName;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }  
    public static int totalBook(){      //定义方法求图书总册数
        return bookNumber-1000;
    }
    
    public String toString(){       //重写toString方法
        return "书名"+this.bookName+",价格"+this.price;
    }
    
}
public class Demo{
    public static void main(String args[]){ 
        Book[] books = {new Book("c语言程序设计",29.3),
                        new Book("数据库原理",30),
                        new Book("Java学习笔记",68)};
        System.out.println("图书总数为："+ Book.totalBook()); 
        for(Book book:books){
            System.out.println(book.toString());
        }
    }   
}

4.什么是单例设计模式？它具有什么特点？用单例设计模式设计一个太阳类Sun。

单例设计模式就是指在设计一个类时只给它添加一个能够自行实例化的实例，单例模式的主要作用就是保证在应用程序中，一个类class只有一个实例存在。

单例模式有以下特点：
　1、单例类只能有一个实例。
　2、单例类必须自己创建自己的唯一实例。
　3、单例类必须给所有其他对象提供这一实例。

单例模式的实现通常有两种方式：“懒汉式”和“饿汉式”。

一：饿汉式，在类的开头就在内部初始化了一个静态变量，也就是不管是你愿意还是不愿意，这个变量已经被定义了，而且还只能在内部进行调用

public class Sun{
       private static final Sun singleton = new Sun();
       private Sun(){
       }
       public static Sun getInstance(){
              return singleton;
       }
}

二：懒汉式，也是通过类的静态变量实现的，但是并没有直接初始化，而是放在方法中来实现，在每次想要使用这个实例的时候再去初始化。如果已经初始化，也不用再次初始化，所以是比较常用方法

public class Sun{
       private static final Sun singleton;//未初始化
       private Sun(){
       }
       public static Sun getInstance(){
              if(singleton == null){
                     singleton = new Singleton();
              }
       }
}

5.理解Java参数传递机制，阅读下面的程序，运行结果是什么？说明理由。

public class Test {
    String str = new String("你好  ");
    char[] ch = { 'w','o','l','l','d' };
    public static void main(String args[]) {
        Test test = new Test();
        test.change(test.str, test.ch);
        System.out.print(test.str);
        System.out.print(test.ch);
    }
    public void change(String str, char ch[]) {
        str = "hello";
        ch[0] = 'W';
    }
}

运行结果：你好 Wolld

原因：下面为个人理解的内存结构图

这个是第一个String类的，但其实String是一个特殊的类，其内容不可改变。

这个是char[]类的。

6.其他总结

在开始写程序之前先把思路理清，把要用到的各种类以及主类都先放上去，不用急着补全代码块，先从最基础的功能写起，没有错误之后再一步步完善更加复杂的功能。比起想到哪写到哪，走走停停，这样一步步做下来往往会更有效率

（二）实验总结

实验内容：

1.按照下列要求完成类的设计

设计一个日期类，用于记录年、月、日，提供对日期处理的常用方法(日期输出格式xxxx-xx-xx）。
设计一个职工类，该职工类至少具有下面的属性：职工号，姓名，性别，生日，工作部门，参加工作时间，设计相应的方法。
设计一个部门类，包括下列属性：部门编号，部门名称，经理，设计相应方法。
设计一个测试类，采用对象数组模拟一个拥有两个部门，10个职工的单位，实现对相关信息的查询功能。

程序设计思路：设计的三个类其中职工类的生日和参加工作时间需要用到日期类，工作部门需要用到部门类，在设计时注意使用相应的setter和getter并添加数据。

2.设计一个计算工具类，要求：

为用户提供几个常见的几何体面积和体积的算法（如球的体积和表面积，圆柱体的体积和表面积，圆锥体的体积和表面积）（可以学习使用static关键字）
设计一个测试类，给出几个不同的圆柱体，圆锥体，球体的尺寸，用计算工具类分别求它们体积的累加和与表面积的累加和。
-设计一个测试类，随机产生球，圆柱、圆锥体的尺寸，模拟考试，要求用户回答它们的体积和面积，并判断用户的回答是否正确

程序设计思路：通过方法的重载来求不同物体的体积和表面积。在模拟考试中通过Random来随机生成物体以及对应的尺寸参数，对比用户输入的数据和正确结果
总结：在模拟考试测试中为了方便计算，需要对体积和表面积进行保留n位小数的转换。

3.用面向对象编程思想完成评分系统

程序设计思路：把每个选手的属性放入类中，通过方法来求最高分，最低分以及最终分，在对象排序时使用比较器Comparable

public int compareTo(Score sc) { 
    if (this.finalscore > sc.finalscore) { 
          return 1;   
    } else if (this.finalscore < sc.finalscore) { 
        return -1; 
    } else { 
        return 0; 
    } 
}

4.用面向对象编程思想编写猜拳游戏

程序设计思路：在计算机玩家类和玩家类中添加姓名name和成绩score，计算机玩家随机三选一，玩家手动三选一，对比即可，相同平局，不同则根据规则增加相应积分，最后积分高的玩家获胜。

（三）代码托管

码云commit历史截图

（四）学习进度条

	代码行数（新增/累积）	学习时间（新增/累积）	本周学习内容
目标	5000行	300小时
第2-4周	300/300	15/15	学习了用Scanner从控制台输入和随机数的创建和应用
第5周	500/500	25/25	String和char[]等之间的相互转化
第6周	550/550	35/35	class类的创建和应用，this关键字，java比较器