【笔记】C++ 转 JAVA 学习笔记_c++ 接口转java-CSDN博客

本文链接：https://blog.csdn.net/Maoziii/article/details/122473736

C++选手初学JAVA记录

1、JAVASE

大四实习，初学java，写个学习笔记

1、JAVASE

JavaSE学习笔记

IDEA快捷键：
Ctrl + d         复制当前一行到下一行
Ctrl + y         删除当前一行
Ctrl + Alt + L   格式化代码
Alt + insert     快速加东西
Alt + Enter      快速补全
Ctrl + Alt + T   快速添加流程控制包裹选中代码

规范命名：
类名首字母大写
方法和属性，首字母小写，后面单词首字母大写

java中数组的写法
int nums[];		     //声明一个数组
nums = new int[10];  //创建一个数组

输出指定长度
String name = "youxiong";
name = String.format("%-16s", name);
System.out.println(name + "length" + name.length());

%-16s ：表示输出固定长度16为，如源字串长度不足16为，-表示右侧补空格至16位；
同样，如果想实现固定输出长度16位，长度不足左侧补空格，可使用%16s。
和c中差不多，指定长度输出

map的用法
HashMap<Integer, Integer> map = new HashMap<>();
map.put(1, 31);
map.get(1);   //该值为31

实例化这个类 new（非静态方法）
对象类型对象名 = 对象值
Student studen = new Student();

构造器：
和类名相同
没有返回值

继承性（子类继承父类）子类继承父类所有的方法（私有无法继承）
（Studen继承Person）
public class Student extends Person{

}

四种修饰符
public
protected
default
private

在java中所有的类都默认继承object类
1、super调用父类的构造方法，必须在构造方法的第一个
2、super只能出现在子类的方法或者构造函数中
3、super和this不能同时调用构造方法

this：本身调用者这个对象没有继承也可以使用
super：代表父类对象的应用只有在继承条件才可以使用

重写：需要有继承关系，子类重写父类的方法
1、方法名必须相同
2、参数列表必须相同
3、修饰符：范围可以扩大：
public > protected > default > private
抛出的异常：范围可以被缩小但不能扩大

重写：子类的方法和父类必要一致；方法体不同

为什么需要重写：
1、父类的功能子类不一定需要，或者不一定满足（override）

一般new的直接执行父类的内容，但如果子类重写了父类
那么执行子类重写的内容

多态注意事项：
1、多态是方法的多态，属性没有多态
2、父类和子类，有联系类型转换异常
3、存在条件：继承关系，方法需要重写

instanceof：判断两个东西是否有关系（返回值true和false）
System.out.println(X instanceof Y);

将父类转换为子类，那么父类就可以使用子类的方法了
Person obj = new Student();
高转低
Student studen = (Student) obj; 方法1
((Student) obj).go(); 方法2
那么就可以使用Student类中的go()方法了

子类转换为父类可能丢失一些自己本来的方法

1、父类引用指向子类的对象
2、把子类转换为父类，向上转型
3、把父类转换为子类，向下转型
4、方便方法的调用，减少重复的代码

普通类：只有具体的实现
抽象类：具体实现和规范（抽象方法）都有
接口：只有规范，自己无法写方法（专业的约束）—约束和实现分离

接口关键字： interface
接口中的所有定义都是抽象的 public

java 是单继承的，可以利用接口实现多继承

继承和多态(person 和 student)
抽象类(abstract)：
抽象类是没有方法体的，抽象类存在的意义是父类提供接口
让子类来重写方法
super 关键字： super 的用法为调用父类的内容
this 为本类的内容

子类如果要调用父类的私有属性输出，可以先重写父类的tostring方法
然后在子类的tostring方法中使用super来调用重写后的父类的方法
就可以完成子类调用父类的属性输出

父类的私有属性，想要赋值，必须要用get，set方法来构造
构造需要有带有带有属性的generate，还有有空的generate

创建对象的时候，可以用子类new子类对象(调用父类属性比较困难)
Student student = new Student(123, “张三”, 25);

还可以用父类来创建子类对象(可以调用父类属性)
Person student = new Student(123, “张三”, 25);

JAVA语言的特性：
封装继承多态
例子(灯泡)
多态体现在同一大类之中，根据实例化对象的不同，可以进行不同的操作

java 继承的主要特性是 父类引用指向子类实例
Buble buble = new RedBuble(“红灯”); // 创建了一个灯泡红
子类对象指向父类实例引用

22/1/19
自定义类的数组创建方式：

Movie movie[] = new Movie[20];
MovieInfo[][] movieInfo = new MovieInfo[10][20];
//创建自定义类的数组空间
//还需要再new一波，才能输入内容
movie[c1] =new Movie();

一：final
final类不能被继承，没有子类，final类中的方法默认是final的。
final方法不能被子类的方法覆盖，但可以被继承。
final成员变量表示常量，只能被赋值一次，赋值后值不再改变。
final不能用于修饰构造方法。
注意：父类的private成员方法是不能被子类方法覆盖的，因此private类型的方法默认是final类型的。

二：static
static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，
也可以形成静态static代码块，但是Java语言中没有全局变量的概念。

被static修饰的成员变量和成员方法独立于该类的任何对象。
用public修饰的static成员变量和成员方法本质是全局变量和全局方法，
当声明它类的对象市，不生成static变量的副本，而是类的所有实例共享同一个static变量。

static变量前可以有private修饰，表示这个变量可以在类的静态代码块中，或者类的其他静态成员方法中使用。
static修饰的成员变量和成员方法习惯上称为静态变量和静态方法，可以直接通过类名来访问，访问语法为：

一个java文件中可以有多个class类，但只能有一个 public class

try catch finally // 捕获异常
Throwable // 最高的捕获等级

HashSet关键字：百度包含的各种方法

遍历方法1：

可以使用迭代器遍历集合
Iterator it = set.iterator();//创建一个迭代器
while(it.hasNext()){
	System.out.println(it.next());
}

遍历方法2：

使用for each迭代集合
//把set每一个值取出来赋值给obj
//直到循环set的所有值
for(Object obj : set){
	System.out.println(obj);
}

22/1/20
如果想在集合只能存同样类型的对象，那么要用到泛型
泛型： Set set1 = new HashSet();
HashSet不能保障元素的排列顺序，不可重复，不是线程安全，集合元素可以使null
使用hash算法来存储集合中的元素，具有良好的存取和查找性能。

TreeSet 自动排序可以重写排序方法

class Person implements Comparator<Person>{
	int age;
	String name;
	@Override
	public int compare(Person o1, Person o2){
		if(o1.age > o2.age){
			return 1;
		}else if(o1.age < o2.age){
			return -1;
		}else{
			return 0;	
		}
	}
}

List：
允许有重复元素，可以通过索引来访问指定位置的集合元素
默认按元素的添加顺序设置元素的索引
添加了一些根据索引来操作集合元素的方法

map的用法:

Map<String, Integer> map = new HashMap<String, Integer>();

map<key, value>

map.put("b", 1); //添加数据
System.out.println(map.get("b")); //根据key取值
map.remove("c"); //根据key移除键值对

hashCode相等,equals也不一定相等, 两个类也不一定相等
equals相同, 说明是同一个对象, 那么hashCode一定相同

==是判断两个变量或实例是不是指向同一个内存空间
equals是判断两个变量或实例所指向的内存空间的值是不是相同

==是指对内存地址进行比较， equals()是对字符串的内容进行比较
==指引用是否相同， equals()指的是值是否相同

enum 枚举类
java int转string：
二、int转String有三种方式

(1)num + “”

(2)String.valueOf(num)

(3)Integer.toString(num)

string转int：
一、String转int有两种方式

(1)Integer.parseInt(str)

(2)Integer.valueOf(str).intValue()

22/1/21
File类:

访问文件名

File f5 = new File("src/day12/Test.java");
System.out.println(f5.getPath());//获取文件或文件夹得路径，就是new file时候写的路径
System.out.println(f5.geyAbsoluteFile()); //获取当前文件的绝对路径
f.renameTo(new File("D:\\test\\abc\\tt1.txt"))； // 给文件或文件夹改名

文件检测

File f6 = new File("D:\\test\\abc");
System.out.println(f6.exits());  //文件是否存在

canWrite() //是否可读or可写
canRead() 
lastModify() //最后修改时间

文件操作相关

if(!f8.exits()){
	try{
		f8.createNewFile();	
	}catch(IOException e){ // 捕获IO异常
		e.printStackTrace;
	}

File f9 = new File("D:\\test\\abc\\cc");
f9.mkdir(); // 创建单级目录
 

文件字节输出流 FileOutputStream
FileOutputStream out = new FileOutputStream("D:/test/abc/tt4.txt");
String str = "sadlakdjalksdjsaldj";
out.write(str.getBytes()); //把数据写到内存
out.flush(); //把内存中的数据刷写到硬盘
out.close(); //关闭流

文件字节流：

文件字节流非常通用，可以用来操作字符的文档，还可以操作任何的其他类型文件
（图片，压缩包等等）因为字节使用的是二进制

文件复制：
public class FileTest1 {
    public static void main(String[] args) {
        FileTest1.copyFile("E:/wyf/文件练习/Test/tt1.txt", "E:/wyf/文件练习/Test/cc/tt2.txt");
    }

    public static void copyFile(String inPath, String outPath){
        try{
            FileInputStream in = new FileInputStream(inPath); //读取文件
            FileOutputStream out = new FileOutputStream(outPath); //复制到CC中的ett1

            byte[] b = new byte[100];
            int len = 0;

            while((len = in.read(b)) != -1){
                out.write(b, 0, len); // 参数1是写的缓冲数组，参数2是从数组那个位置开始写，参数3是写的长度
            }

            out.flush();//写到内存的数据刷到硬盘
            out.close();//关闭这些东西
            in.close();


        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

文件字符流：

读取文件内容：

public class Test2 {
    public static void main(String[] args) {
        Test2.testFileReader("E:/wyf/文件练习/Test/tt1.txt");
    }

    public static void testFileReader(String inPath){
        try {
            FileReader fr = new FileReader(inPath);

            char c[] = new char[100];
            int len = 0;

            while((len = fr.read(c)) != -1){   //文件长度~~
                System.out.println(new String(c, 0, len));   // 输出~~
            }

            fr.close();

        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

写文件内容：

    public static void testFileWriter(String text, String outPath){
        try{
            FileWriter fw = new FileWriter(outPath);
            fw.write(text); // 写到内存中
            fw.flush();//内存中的数据刷到硬盘
            fw.close();//关闭流
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

问：为什么有字节流了还要有字符流的存在？
答：二者处理的基本单位不同，字符流是专门处理字符串的，
字节流有时候不适合处理字符串，因为有些编码是变长度的。
比如当你要读取流中前三个字符，字符编码又是utf-8的话，
你用字节流没办法确定要读取几个字节，字符流的话直接读取三个字符就可以了。

缓冲流：
字符流和字节流都是基于计算机与硬盘之间发生的IO操作，速度收到硬盘读写速度的制约
为了能提高读写速度，java提供了缓冲流来实现

BufferedInputStream
BufferedOutputStream

BufferedReader
BufferedWriter

缓冲流就是把数据先缓冲到内存之中，然后在内存中做IO操作，比硬盘的IO操作快很多倍

缓冲流具体应用：

public class Test3 {
    public static void main(String[] args) throws Exception {
        Test3.testBufferedInputStream();

    }
    public static void testBufferedInputStream() throws Exception { //直接抛出异常

        //文件字节输入流对象
        FileInputStream in = new FileInputStream("E:\\wyf\\代码相关\\java\\playpp\\demo1\\src\\JavaSE\\demo05\\tt.txt");

        //缓冲字节输入流对象
        BufferedInputStream br = new BufferedInputStream(in);           //把文件字节流输入缓冲区

        byte[] b = new byte[10];

        int len = 0;

        while((len = br.read(b)) != -1){        //读到-1就是没有了
            System.out.println(new String(b, 0, len));
        }

        //关闭流的顺序是栈顺序
        br.close();
        in.close();

    }
    public static void testBufferedOutputStream() throws Exception {
        //创建字节输出流对象
        FileOutputStream out = new FileOutputStream("E:\\wyf\\代码相关\\java\\playpp\\demo1\\src\\JavaSE\\demo05\\tt1.txt");
        //把字节输出流对象放到缓冲字节输出流中

        BufferedOutputStream bo = new BufferedOutputStream(out);//new一个新对象

        String s = "Hello World!!!";
        bo.write(s.getBytes(StandardCharsets.UTF_8));  //写到内存之中
        bo.flush(); //刷到硬盘之上
        
        bo.close();
        out.close();
        
    }
}

关于路径的斜杠信息：
1.这些符号在不同的系统下意义不同：

//双斜线：协议和主机名之间的分隔符 (比如http://localhost:8080)

/单斜线：windows里或者WEB上或者Unix内核的目录架构分隔符

\反斜线：windows 里的目录结构的分隔符，正斜线也可。

\双反斜线：在windows里表示绝对地址的第一项，比如后面跟上IP地址的话，就是需要打开这个IP地址的网络共享资源。

异常处理：
关键字:throw,throws,try和catch的用法如下：
1、throws出现在方法的声明中，表示该方法可能会抛出的异常，允许throws后面跟着多个异常类型
2、throw出现在方法体中，用于抛出异常。当方法在执行过程中遇到异常情况时，将异常信息封装为异常对象，然后throw。
3、try出现在方法体中，它自身是一个代码块，表示尝试执行代码块的语句。如果在执行过程中有某条语句抛出异常，那么代码块后面的语句将不被执行。
4、catch出现在try代码块的后面，自身也是一个代码块，用于捕获异常try代码块中可能抛出的异常。catch关键字后面紧接着它能捕获的异常类型，所有异常类型的子类异常也能被捕获。

1/26
String字符串处理的几个函数
String.trim(); //去除首尾空格
String.substring(); //切分字符串
String.split(); //切分字符串

字符串初始化的时候的时候，定义空串尽量使用：str = “”;

反射和重载：
反射构造对象是逆向过程，先加载类，再通过类来反射父类，再通过父类来调用
逆向过程
重载是正向过程
默认是调用默认构造
反射可以调用指定构造

1/28
str.append(); //
Stringbuffer 有append()方法
Stringbuffer其实是动态字符串数组
append()是往动态字符串数组添加，跟“xxxx”+“yyyy”相当那个‘+’号
跟String不同的是Stringbuffer是放一起的
String1+String2 和Stringbuffer1.append(“yyyy”)虽然打印效果一样，但在内存中表示却不一样
String1+String2 存在于不同的两个地址内存
Stringbuffer1.append(Stringbuffer2)放再一起