序

第一周情况

完成了Java编程与环境变量与编译器的安装，顺利完成了hello world 的输出。

对照C++基本了解其基本语法，选择，循环。

正在将以前的C++ C例题转换为JAVA代码

 

本周所遇到的问题

目前JAVA最令我耳目一新的是独有的数组机制，没有指针的概念，不需要提前对对内存进行分配，感觉比C++很只能。

C++与Java的服务领域

我并不知道编程语言的服务领域。很早之前就听说C++适合干嘛干嘛，JAVA适合干嘛干嘛的。但是我在本周的学习中，我并不能区分这两种语言的领域

 

下周计划

下下周要出去旅游，加快Java的学习速度

 

六月二十五日

安装了JDK和eclipse，用javac命令和java命令进行编译和运行java

写了经典代码

?
1
2
3
4
5
public class HelloWorld<br>{
    public static void main(String[] args)<br>    {
        System.out.println("HelloWorld");
    }
}

在Java中，主函数实在类中，这一点与C++相去甚远。刚开始认为Java中没有了主体，都是一个个类组成，那么只有顺序执行了。

这一点就令我很疑惑

 

六月二十六日

带着昨天的疑惑，我去翻译C++的代码，将其翻译为Java的代码再去考虑Java的代码规则

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Factorial {
    public static void main(String[] args) {
        int number = 5; // 要计算阶乘的数字
 
        long factorial = calculateFactorial(number);
        System.out.println(number + " 的阶乘是: " + factorial);
    }
 
    public static long calculateFactorial(int n) {
        if (n == 0) {
            return 1;
        } else {
            return n * calculateFactorial(n - 1);
        }
    }
}

一个简单计算阶乘的程序，我才了解到类中可以在加类，这里的类与C++中的不同，似乎相当于函数。

将类看作是函数，Java的代码就清晰很多了，与C++相似的语言也另我亲切不少。

 

六月二十七日

 

通过进一步了解JAVA，发现一个非常智能的规则。在Java中数组可以存储任何类型的数据对象，将C++中list容器的优点结合在一起。并且数组中可以实现动态大小，并且可以随时知道数组的长度。

既然Java数组中不再具有只能存储单一类型数据，那么迭代器与指针就没有区别。Java中就不再需要指针。我认为这个设点非常智能

在Java中，数组还具有各种各样的函数，可以进行各种功能，并且不需要头文件进行预编译，节省了时间。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
以下是一些常见的Java数组操作代码的示例：
 
1. 声明和创建数组：
 
int[] numbers = new int[5]; // 声明并创建长度为5的整数数组
String[] names = {"Alice", "Bob", "Charlie"}; // 声明并使用初始值创建字符串数组
 
2. 访问数组元素：
 
int firstNumber = numbers[0]; // 获取数组的第一个元素
String lastName = names[2]; // 获取数组的第三个元素
 
3. 修改数组元素：
 
numbers[1] = 10; // 修改数组的第二个元素为10
names[0] = "Alex"; // 修改数组的第一个元素为"Alex"
 
4. 获取数组长度：
 
int length = numbers.length; // 获取数组的长度
 
 
5. 遍历数组：
 
 
for (int i = 0; i < numbers.length; i++) {
    System.out.println(numbers[i]); // 遍历并打印数组元素
}
 
for (String name : names) {
    System.out.println(name); // 使用 foreach 循环遍历并打印数组元素
}
 
 
6. 多维数组操作：
 
java
int[][] matrix = {{1, 2, 3}, {4, 5, 6}}; // 声明并使用初始值创建二维数组
int element = matrix[1][2]; // 访问二维数组的元素
 
matrix[0][1] = 10; // 修改二维数组的元素
 
 
7. 使用 `Arrays` 类进行排序和搜索：
 
 
int[] numbers = {5, 3, 7, 1, 9};
Arrays.sort(numbers); // 对数组进行排序
 
int index = Arrays.binarySearch(numbers, 7); // 在数组中搜索元素的索引

六月二十八日

 

根据C++的学习经验，选择，循环，数组与字符串，指针，类，文件的顺序

既然Java中的类类似与C++的函数，那么Java中的与C++类类似的是什么。我发现还是类，相当于推翻了我之前的判断。

Java中类的关联好像有着某种关系。似乎是不同的物品，通过一条线来串联。在C++中，都需要在类的本身中进行某种设定（抽象，虚拟）。

通过这个关联性，我初认为Java中的类更加灵活多样。但是java中的类只能进行单继承，一个类只能有一个父类，这无疑是大大降低了复杂性，歧义性。

并且Java中的内存管理是自动化的，相较于C++更失一些精细化

所以我最后认为C++中的类是更加灵活的

 

六月二十九日

继续学习类。

参考C++的构造函数，拷贝构造函数，析构函数，开始学习Java的类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
1. 构造方法（Constructor）：Java中的构造方法类似于C++的构造函数，用于创建对象并进行初始化。构造方法与类名相同，没有返回类型，并且可以有多个构造方法的重载。
 
public class MyClass {
    private int myNumber;
     
    // 无参构造方法
    public MyClass() {
        // 构造方法初始化对象
        myNumber = 0;
    }
     
    // 带参构造方法
    public MyClass(int number) {
        myNumber = number;
    }
}
 
2. 拷贝构造方法（Copy Constructor）：Java中没有直接的拷贝构造方法，但可以通过克隆（Clone）接口来实现类似的功能。克隆接口（Cloneable）允许对象在内存中进行复制。
 
 
public class MyClass implements Cloneable {
    private int myNumber;
     
    public MyClass(int number) {
        myNumber = number;
    }
     
    // 克隆方法
    public MyClass clone() throws CloneNotSupportedException {
        return (MyClass) super.clone();
    }
     
    // 使用克隆方法创建新对象
    public void copyObject(MyClass other) throws CloneNotSupportedException {
        MyClass newObj = other.clone();
        // 复制对象的属性或其他操作
    }
}
 
 
3. 垃圾回收器（Garbage Collector）：Java使用垃圾回收器来自动管理内存，无需手动调用析构函数进行对象的销毁。垃圾回收器会自动检测和回收不再使用的对象。Java提供了一个特殊的方法`finalize()`，用于在垃圾回收器回收对象之前进行清理操作。
 
 
public class MyClass {
    private int myNumber;
     
    public MyClass(int number) {
        myNumber = number;
    }
     
    // finalize 方法
    protected void finalize() throws Throwable {
        // 在对象被回收之前进行清理操作
        super.finalize();
    }
}

　　

六月三十日

当开始学习Java的文件操作时，我又发现上面一个错误。Java中是存在标准库的，但是数组的一些操作函数似乎是本身具有的，不需要像C++中写库函数

但是在文件操作中，Java也需要写标准库

Java与C++的文件操作似乎有非常多的相似点，一样的流式操作，对文件创建，写入，读取，删除

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
创建文件：
import java.io.File;
import java.io.IOException;
 
public class FileOperations {
    public static void main(String[] args) {
        try {
            File file = new File("myfile.txt");
            if (file.createNewFile()) {
                System.out.println("文件创建成功！");
            } else {
                System.out.println("文件已存在！");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
写入文件：
import java.io.FileWriter;
import java.io.IOException;
 
public class FileOperations {
    public static void main(String[] args) {
        try {
            FileWriter writer = new FileWriter("myfile.txt");
            writer.write("Hello, World!");
            writer.close();
            System.out.println("写入成功！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
读取文件：
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
 
public class FileOperations {
    public static void main(String[] args) {
        try {
            BufferedReader reader = new BufferedReader(new FileReader("myfile.txt"));
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
            reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
删除文件：
import java.io.File;
 
public class FileOperations {
    public static void main(String[] args) {
        File file = new File("myfile.txt");
        if (file.delete()) {
            System.out.println("文件删除成功！");
        } else {
            System.out.println("文件删除失败！");
        }
    }
}

　　

七月一日

Java的基本语言已经明白，接下来开始写编程题了

与C++一样的思路，写题熟练一下Java的语法规则

1.（风扇类Fan）设计一个名为Fan的类来表示一个风扇。这个类包括：

三个名为SLOW、MEDIUM、FAST而值是1、2和3的常量表示风扇的速度。

一个名为speed的int类型私有数据域表示风扇的速度（默认值为SLOW）。

一个名为on的boolean类型的私有数据域表示风扇是否打开（默认值为false）。

一个名为radius的double类型的私有数据域表示风扇的半径（默认值为5）。

一个名为color的String类型的数据域表示风扇的颜色（默认值为blue）。

这四个数据域的访问器和修改器。

一个创建默认风扇的无参构造方法。

一个名为toString（）的方法返回描述风扇的字符串。如果风扇是打开的，那么该方法在一个组合的字符串中返回风扇的速度、颜色和半径。如果风扇没有打开，该方法就返回一个由“fan is off”和风扇颜色及半径组合成的字符串。

实现这个类。编写一个测试程序，创建两个fan对象。将第一个对象设置为最大速度、半径为10、颜色为yellow、状态为打开。将第二个对象设置为中等速度、半径为5、颜色为blue、状态为关闭。通过调用它们的toString方法显示这些对象。

 

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
public class Fan_test
 
{
 
public static void main(String[] args) {
 
Fan F1=new Fan();
 
Fan F2=new Fan();
 
F1.setSpeed(F1.FAST);
 
F1.setRadius(10);
 
F1.setColor("yellow");
 
F1.setOn(true);
 
F2.setSpeed(F2.MEDIUM);
 
F2.setRadius(5);
 
F2.setColor("blue");
 
F2.setOn(false);
 
System.out.println("第一个风扇：");
 
System.out.println(F1.toString());
 
System.out.println("第二个风扇：");
 
System.out.println(F2.toString());
 
 
 
}
 
}
 
class Fan {
 
Fan()
 
{
 
speed =SLOW;
 
on=false;
 
radius=5;
 
color ="blue";
 
}
 
final int SLOW=1;
 
final int MEDIUM=2;
 
final int FAST=3;
 
private int speed =SLOW;
 
private boolean on=false;
 
private double radius=5;
 
String color ="blue";
 
//访问器
 
public int getSpeed() {
 
return speed;
 
}
 
 
 
public boolean isOn() {
 
return on;
 
}
 
 
 
public double getRadius() {
 
return radius;
 
}
 
 
 
public String getColor() {
 
return color;
 
}
 
//修改器
 
public void setSpeed(int speed) {
 
this.speed = speed;
 
}
 
 
 
public void setOn(boolean on) {
 
this.on = on;
 
}
 
 
 
public void setRadius(double radius) {
 
this.radius = radius;
 
}
 
 
 
public void setColor(String color) {
 
this.color = color;
 
}
 
 
 
public String toString()
 
{
 
if(this.on==true)
 
{
 
return "风扇的速度为："+this.speed+" 风扇的颜色为："+this.color+" 风扇的半径为："+this.radius;
 
}
 
else {
 
return "fan is off."+" 风扇的颜色为："+this.color+" 风扇的半径为："+this.radius;
 
}
 
}
 
}

　在知乎上面找的题目，最后对着答案进行修改完善

posted @   财神给你送元宝  阅读(18)  评论(0)  编辑  收藏  举报
相关博文：
· 软件设计模式————（迭代器模式）
· 第二周 第一天 七月二日
· 暑假生活Java自学习
· Java个人学习笔记
· 第三天--数组和面向对象编程
阅读排行：
· Manus重磅发布：全球首款通用AI代理技术深度解析与实战指南
· 被坑几百块钱后，我竟然真的恢复了删除的微信聊天记录！
· 没有Manus邀请码？试试免邀请码的MGX或者开源的OpenManus吧
· 园子的第一款AI主题卫衣上架——"HELLO! HOW CAN I ASSIST YOU TODAY
· 【自荐】一款简洁、开源的在线白板工具 Drawnix
点击右上角即可分享
微信分享提示