序

第一周情况

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

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

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

 

本周所遇到的问题

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

C++与Java的服务领域

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

 

下周计划

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

 

六月二十五日

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

写了经典代码

public class HelloWorld
{
    public static void main(String[] args)
    {
        System.out.println("HelloWorld");
    }
}

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

这一点就令我很疑惑

 

六月二十六日

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

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中，数组还具有各种各样的函数，可以进行各种功能，并且不需要头文件进行预编译，节省了时间。

以下是一些常见的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. 构造方法（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++的文件操作似乎有非常多的相似点，一样的流式操作，对文件创建，写入，读取，删除

创建文件：
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方法显示这些对象。

 

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;

}

}

}

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