《Java技术》第三次作业
Java第三次作业
一 . 学习总结
1.面向对象的封装性，Java中实现封装性方法
- 面向对象的封装性:
就是保护对象的某些内容，保证某些属性或方法不被外部看见。- 封装的实现 :
为属性封装 : private 属性类型 属性名称；
为方法封装：private 方法返回值 方法名称(参数列表)
注意：封装后的内容外部无法调用，需要编写setter与getter方法完成调用。- 实例 :
class Personal{
private String name; //声明姓名属性
private int age; //声明年龄属性
public void setName(String n){ //setter设置姓名属性
name = n;
}
public void setAge(int a){ //setter设置年龄属性
if(a>=0 && a<=150){
age = a;
}
}
public String getName(){ //getter取得属性
return name;
}
public int getAge(){ //getter取得属性
return age;
}
public void tell(){
System.out.println("name is :" + name + ", age is :" + age);
//System.out.println("name is :" + this.getName() + ", age is :" + this.getAge());
}
}
public class EncDemo02 {
public static void main(String args[]){
Personal per = new Personal(); //声明并实例化对象
per.setName("zhaojianyu"); //调用setter设置姓名
per.setAge(21); //调用setter设置年龄
per.tell();
}
}
2.static关键字
- (1) static 关键字的调用
- 用private对属性进行封装时，需要使用setter，getter方法进行调用，但是此程序只需要把private修改为static就可以进行++运算，static类型的属性是所有对象共享的。
- 修改后代码 :
class test {
static int secret = 5;
}
public class Test {
public static void main(String args[]) {
test a = new test();
System.out.println(a.secret++);
}
}
- (2) static 关键字的静态引用
- 当声明X变量时，应该定义为static类型，static只能调用static内容。
- 修改后代码 :
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[]){
excise.method();
}
}
3.Book类
-
修改后代码 :
class Book { //对属性进行封装 private int bookId; private String bookName; private double price; // 声明静态变量 private static int bookNum; // 定义静态代码块对静态变量初始化,只执行一次 static { bookNum = 1000; } // 构造方法 public Book() {//无参方法 } public Book(String bookName,double price) { this.bookName = bookName; this.price = price; bookId = bookNum; bookNum++; } 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(){ int bookSum = bookNum - 1000; return bookSum; } // 重写toString方法 public String toString(){ return "图书编号 : " + bookId + " " + "图书名称 : " + this.bookName + " " + "图书价格 : " + this.price; } } 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()); } } }
4.单例设计模式的含义与特点
- 含义 :
单例模式是一种常用的软件设计模式，在它的核心结构中只包含一个被称为单例的特殊类。 - 特点 :
1.某个类只能有一个实例
2.它必须自行创建这个实例
3.它必须自行向整个系统提供这个实例 - 实例 :
- 第一种方式 : 饿汉式单例类
public class Sun {
private Sun(){}
//注意这是private 只供内部调用
private static Sun instance = new Sun();
//这里提供了一个供外部访问本class的静态方法，可以直接访问
public static Sun getInstance() {
return instance;
}
}
> * 第二种方式 : 懒汉式单例类
public class Sun {
private static Sun instance = null;
public static synchronized Sun getInstance() {
//这个方法比上面有所改进，不用每次都进行生成对象，第一次调用时初始Sun，以后就不用再生成了
//使用时生成实例，提高了效率
if (instance == null)
instance = new Sun();
return instance;
}
}
5.Java参数传递机制
- 运行结果 :
你好 Wolld - 运行结果原因 :
栈与堆的关系：
public class excise {
String str = new String("你好 ");
char[] ch = { 'w','o','l','l','d' };
public static void main(String args[]) {
excise test = new excise();
test.change(test.str, test.ch);
System.out.println(test.str);
System.out.println(test.ch);
}
public void change(String str, char ch[]) {
str = "hello";
ch[0] = 'W';
}
}
6.其他知识总结
- 简单类设计的步骤：
- 首先，建立简单的程序框架，也就是你需要写几个类来完成你的程序
- 其次，为你创建的每个类声明相应的属性，并未其调用setter与gstter方法
- 接着，构造无参方法，有参方法，参数为你创建的属性，为其赋值，用this关键字
- 然后，写出toString()方法，对属性值进行输出
- 最后，在主方法中，构造对象，利用对象，有逻辑的调用你的类中的方法，从而完成程序的要求
- 重要的是 ： 遇见困难不要马上去问别人，自己缕清思路再进行修改
二 . 实验总结
1.日期类，部门类，员工类，测试类
-
程序设计思路：
按照要求创建四个类，每个类声明相应的属性并封装，再进行setter与gstter方法的调用，创建无参构造方法，再创建有参构造方法，最后用toString()方法进行输出属性值。在类与类之间有相应的联系，进行关联操作，最后在测试类里进行构造对象数组，对象调用方法，进行测试与输出信息。 -
问题1：
在测试类进行创建员工类对象数组时，忘记在部门类对员工类对象数组进行关联 -
原因：没有真正明白类之间的关系与如何创建关联
-
解决方案：
在部门创建员工类对象数组，接着调用setter与gstter方法，在主方法进行实例化//在部门类创建对象数组 private Employee emps[]; public Employee[] getEmps() { return emps; } public void setEmps(Employee[] emps) { this.emps = emps; } //主方法进行实例化 Employee[] emps = { new Employee(此处加入员工信息，与在员工类创建的有参构造方法一样的参数), new Employee(), new Employee(), new Employee(), new Employee(),};
2.计算工具类，测试类1，测试类2
-
程序设计思路：
按照创建三个类，在计算工具类声明相应的属性并调用setter与gstter方法，创建无参与有参构造方法，在测试类中调用计算工具类的方法实现要求 -
问题1：
在测试类2中，声明用户，对其计算结果进行判断，用户分别计算六个题输入答案，不知如何进行简单的判断，出现了重复语句多次 -
原因：
搞不清自己想要怎么判断，思路不清晰 -
解决方案：
把用户的答案放入数组，把你计算的答案放入数组，利用循环进行判断，就可以不重复输出//对数组进行动态实例化 double[] m = new double[6]; double[] s = new double[6]; //对用户答案分别进行判断 for (int i = 0; i < 6; i++) { if (s[i] == m[i]) { System.out.println("恭喜您第" + (i+1) + "题答对啦~~~~~~"); } else { System.out.println("很遗憾您第" + (i+1) + "题答错了~~~~~~"); } }
3.面向对象的评分系统
-
程序设计思路：
创建两个类，选手类与测试类，声明相应的属性并调用setter与gstter方法，创建无参与有参构造方法，按照要求完成输出信息 -
问题1：
开始不知道如何使用Comparable接口的compareTo方法 -
原因：
没有研究明白两个对象比较的关系 -
解决方案：
看书对例子进行研究后明白了如何使用，代码如下 :public int compareTo(Player a) { if (this.pgrade > a.pgrade) { return 1; } else if (this.pgrade < a.pgrade) { return -1; } else { return 0; }
4.猜拳游戏
-
程序设计思路：
创建了三个类，电脑游戏者类，个人游戏者类，还有测试类，在测试进行对游戏的控制 -
问题1：
计算每个人赢的次数时，比较的是电脑类与个人类的出拳结果 -
原因：
这两个类的结果返回值类型是void，所以在主方法中无法判断两者是否相等，以至于无法计算 -
解决方案：
//ComputerPlayer类 public String gameBagin() { //代码段 return str;//这里的str是出拳结果 } //PersonPlayer类 public String gameBagin() { //代码段 return str;//这里的str是出拳结果 } 在主方法中，创建电脑类与个人类的对象，调用各自的出拳方法，并赋值给两个字符串，进行判断
三 .代码托管
- 码云commit历史截图
四 .学习进度条
| 进程 | 代码行数（新增/累积） | 学习时间（新增/累积） | 本周学习内容 |
|---|---|---|---|
| 目标 | 5000行 | 300小时 | |
| 第2-4周 | 500/500 | 45/45 | 自学了前四章的内容，自己练习了学习过程中的所有代码，并写了一些练习题提交到了码云中 |
| 第5周 | 200/700 | 15/55 | 学习了老师要求的内容 |
| 第6周 | 300/1000 | 15/70 | 学习了作业中要求的内容 |
