Java小白学习心得（一）

本文主要整理一些java需要注意的点
主要参考：https://www.bilibili.com/video/av45569853?p=132

Java语言特征：

类->对象->属性（成员变量）、行为（成员方法）

面向过程（eg.C）：当需要实现一个功能时，看重每一个步骤怎么做，整体过程怎样，每个操作需要自己亲历亲为
面向对象：当需要实现一个功能时，不看重具体步骤怎么做，关心“谁能帮我做”

封装性：private
继承性
多态性

类

java中代码的基本组织单位（eg.eclipse中java源码使用class文件）

同一包内不同类可直接调用

一个java文件中可以定义多个类，但是最多只有一个类被public修饰，并且这个类的类名与文件名必须相同，若这个文件中没有public的类，则文件名随便是一个类的名字即可。需要注意的是，当用javac指令编译有多个类的Java文件时，它会给每一个类生成一个对应的.class 文件

class test{
	String name;
	int number;
	public print()
}//创建类

test one = new test(); //创建对象
int number = test.number; //调用对象

定义一个标准的类（POJO：plain old java object）：
1.所有成员变量使用private关键字私有化
2.为每一个成员变量编写一堆getter/setter
3.编写一个无参数构造方法
4.编写一个有参数构造方法

//定义一个标准的类
public class Student{

	//私有化
	private String name;

	//getter/setter
	public String getName(){
		return name;
	}
	public void setName(String name){
		this.name=name;         //注意this区分成员变量
	}
	
	//构造方法
	public Student(){
	}
	public Student(String name){
		this.name=name;
	}
}

方法

~函数
java中main是一个方法，其中不能定义新方法

public class HelloWorld{
	public static void main(String[] args){//固定写法，基本不变，程序起点
	}
}

//方法定义示例
public static int sum(int a, int b){
	int result = a + b;
	return result;
}

构造方法

专门用来创建对象的方法。（通过new创建对象时，其实是在调用构造方法）

在创建一个对象的时候，至少要调用一个构造方法（默认：默认构造方法的访问修改符和类的访问修改符相同）。

构造方法的名称必须与类同名，一个类可以有多个构造方法。

构造方法不能写返回值类型

一旦你定义了自己的构造方法，默认构造方法就会失效。

public class Person{
	public Person() {
	}
	//构造方法
}

Person one = new Person(); //调用构造方法

调用有参数的构造方法创建对象可简化赋值

public class Person{
	private String name;
	private int age;
	public Person(String str, int num) {
		name=str;
		age=num;
	}
	//构造方法
}

source->可自动生成

成员方法：

普通方法去掉static关键字
在对象中储存方法区中对应地址值

方法重载（overload）：

名字相同，参数列表不同的函数自动适配

参数传递规则：

1.基本数据类型+String：形参操作不影响实际参数
2.引用类型（除String）：形参操作影响实际参数

变量

局部变量：方法中（没有默认值）
方法参数是成员变量

成员变量：方法体之外（直接写在类当中）

类变量：类中方法体之外，static类

对象

通过对象名，想用谁.谁

2.JDK

JDK: java development kit
JRE: java runtime environment
JVM: java virtual machine；管理内存

java内存分配

1.stack: local var
方法运行需要进栈
2.heap: new（除基本类型+Sring） -> 默认值规则
3.method area: 存放与.class相关信息（最先有数据）
4.native method area: ~OS
5.pc register: ~CPU

编译

$ javac HelloWorld.java //将java源文件编译为class字节码文件
$ java HelloWorld  //运行生成的class文件

数据类型

1.基本类型

整数、浮点、字符、布尔

java中中文一个字算一个字符

+可用于字符串连接；任何数据型和字符串进行连接操作都一定是字符串；注意顺序

2.引用类型

String str="Hello"+10+20;
System.out.println(str);
//得到输出Hello1020

int[] arrayA = new int[5]; //动态初始化数组
/*动态初始化数组时，元素有默认值：
*整数：0  浮点数：0.0  字符：'\u0000'(unicode)  boolean：false 
*引用类型：null
*/
int[] arrayB = new int[] {1,2,3}; 
int[] arrayB = {1,2,3};
//静态初始化数组
int a = arrayA.length; //数组长度
System.out.println(array); //16进制地址

引用类型使用基本步骤

1.导包

//public class之前
import 包路径名

所有的类都需要导包才能使用，除了两种情况：
A.要使用的目标类和当前类位于同一个包下
B.要使用的目标类位于java.lang包下，但不包括子包

2.创建
数据类型 变成名称 = new 数据类型();

3.使用
变量名称.方法名();

Scanner sc = new Scanner(System.in);

“==”对引用类型表示地址的比较：
如果是两个对象，则地址值必然不同；如果地址值相同必为同一个对象

字符串

String类位于java.lang包下

1. String是对象，为什么直接打印出来是内容（而非地址）？

打印println方法逻辑：
1.如果是String则直接显示内容
2.如果不是，内部转换为String再显示
一般对象使用“类型信息+@+地址值”作为字符串内容

2. 需要熟悉的方法

//构造方法
public String(char[] array);
public String(char[] array, int offset, int count);

//内容比较（区分大小写）
public boolean equals(Object obj);  //Object:可以接收任何类型的数据
boolean same = str1.equals(str2);
System.out.println("abc".equals(str));  //常量尽量写在前面：避免NullPointerException 
//内容比较（不区分大小写）
public boolean equalsIgnore(String str);

//字符串替换（敏感词过滤）
public String replace(CharSequence oldStr, CharSequence newStr);  //CharSequence:简单认为就是String(接口)
String str1="hello";
String str2=str1.replace("e","a");  //str1:"hello",str2:"hallo"

/*字符串切割
 *注意不要用"."切割
 *一定要使用时使用"\\."
 */
public String[] split(String regex);  //regex:正则表达式
String str1="a,b,c";
String[] str = str1.split(","); //str={a,b,c}

3. 字符串池：

1.位于堆内的一小块儿空间，用来保存若干个字符串的地址值
2.字符串池中字符串不重复->节省内存
3.直接双引号创建的字符串默认在池中，new出的不在（内容一样分别new->不同对象）

4. 字符串内容不可变

好像变了一定是创建了新的字符串

集合

数组长度不可以改变，集合长度可任意改变

ArrayList、HashSet、LinkedList、HashMap…

ArrayList

<>代表泛型：可以放哪种类型
泛型只能是引用类型

ArrayList直接打印对象名称而非地址值，格式和数组类似：
toString方法有特殊处理

• 需要熟悉的方法

import java.util.ArrayList;

//构造方法
public ArrayList();
ArrayList<String> list = new ArrayList<>();

//添加元素
public boolean add(E element);  //对于ArrayList返回值一定为true
list.add("a");    //可单独调用

//获取元素
public E get(int index);
System.out.println(1);  //a

//获取长度
public int size();
System.out.println(list.size()); //1

• 存储基本数据类型

使用基本类型对应的“包装类”

byte Byte
short Short
… …
int Integer
char Character

ArrayList<Interger> list = new ArrayList<>();
list.add(1);

关键字

1.private

只能在类中直接使用，类外面不能直接访问->确保安全性

setter/getter方法（source->构造）

boolean类型的getter方法需写为isXXX的形式

public class Person(){
	boolean male;
	public boolean isMale(){  //getMale
		return male;
	}
}

2.static

方便在没有创建对象的情况下来进行调用

3.this

当局部变量和成员变量重名时，方法当中会根据“就近原则”使用局部变量
如果希望区分一下，需要使用格式：this.成员变量名

经典作用：将重名的成员变量和局部变量区分

代表“当前对象”——通过谁调用的方法，谁就是this

public class Person{
	String name;  //自己名字
	public void Hello(String name){  //对方名字
		System.out.println(name + ",Hello,I'm" + this.name+'.');
	}

}

API

/** 表示文档注释

~字典目录

index.html

IO 流

字节流：可以处理任何一种文件数据
字符流：只能处理纯文本文件

字符存储

ASCII码表
unicode万国码：所有文字

FileWriter

希望将数据写到纯文本文件当中

import java.io;

/*1.如果指定文件不存在自动创建（project目录下）
 *右键project->show in->system explorer
 *eclipse中刷新一下可看到
 *2.如果指定文件已存在则覆写
 *3.构造时如果有异常：add throws
 */
public FileWriter(String fileName);  //参数字符串时文件路径名称
FileWriter fw = new FileWriter("file01.txt");  //文件扩展名只能决定默认用什么软件打开文件，不能决定其内容（只能是纯文本文件）

//写数据
public void write(Sring str);
fw.write("Hello");

//关闭流：释放相关资源（才能写入！）
public void close();
fw.close;

//追加：append为true时追加写入
public FileWriter(String fileName,boolean append);
FileWriter fwB = new FileWriter("file01.txt",true);
fwB.write("World");
fwB.close();

//换行写入   换行符———win:\r\n   linux:\n

FileReader

import java.io;

//构造
public FileReader(String fileName);  //文件路径名
FileReader fr = new FileReader("file01.txt");

//读取单个字符（下一个），没有更多字符时输出-1
//每次调用read方法都会尝试读取下一个新字符
public int read();        //对应ASCII或unicode
int temp=fr.read();
while(temp!=-1){
	System.out.println((char)temp);
	temp=fr.read();
}
/*另一种写法：
int tempA;
while((tempA=fr.read())!=-1){
	System.out.println(tempA);
}
*/

//读取多个字符
public int read(char[] buf);  //返回值：数组中读取到的有效个数
char[] buf=new char[2];
int len=fr.read(buf);  //-1代表没有更多内容
String str=new String(char,0,len);  //只取有效个数

//关闭流
public void close();
fr.close();

BufferedWriter

BufferedWriter内部有一个长度为8192的char[]字符数组，当作缓冲区使用
每次在写数据时，都是在不断地向缓冲数组中添加字符：不直接写入硬盘->提高效率
若缓冲数组已满，则统一写到硬盘文件当中
若还没写满，则等待下一次写入
若最终关闭流时仍没满也会写入

1.创建一个普通的FileWriter
2.将fw包装为BufferedWriter
3.后面的使用方法与fw基本一样

import java.io;

//构造方法
public BufferedWriter(FileWriter fw);
FileWriter fw = new FileWriter("file01.txt");
BufferedWriter bf = new BufferedWriter(fw);

//基本方法
bw.write("hello");

//换行
public void newLine();  //根据系统自动选择换行符,兼容性更好
bw.newLine();
bw.write("World");

//关闭
bw.close();        //仅需close外面的

BufferedReader

BufferedReader内部有一个长度为8192的char[]字符数组，当作缓冲区使用
读取数据时一次性读最多8192个字符，放在缓冲区中
调用read方法时从缓冲区中拿出使用
若取空则再次读取最多8192个

import java.io;

//构造
FileReader fr = new FileReader("file01.txt");
BufferedReader br = new BufferedReader(fr);

//基操
char[] buf=new char[2];
int len;
while((len=br.read(buf))!=-1){
	String str=new String(buf,0,len);
	System.out.println(str);
}

//读一行
public String readLine();  //不包含换行符
String line;
while((line=br.readLine())!=null){
	System.out.println(line);             //以行输出
}

//关闭
br.close();