从零开始学Java

卡尼杉纳

已于 2024-05-27 10:25:40 修改

阅读量1k

点赞数 33

文章标签： java 开发语言

于 2024-05-26 21:10:16 首次发布

本文链接：https://blog.csdn.net/2301_79781443/article/details/139220546

版权

从零开始学Java

自用笔记方便查阅，课程来自黑马程序员

IDEA快捷键合集：

	psvm + [Enter] -> main方法
	sout + [Enter] -> 打印
	ctrl + d ->向下复制一行
	alt + insert(ins) -> 快捷构造(按不出来的话多按个Fn)
	array.fori + [Enter] -> 遍历数组
	array.forr + [Enter] -> 倒着遍历数组
	str.lenth().fori + [Enter] -> 遍历字符串
	ctrl + alt + t -> 在一段代码外加一层代码（循环之类的）
	ctrl + shift + u -> 小写字母变大写

常用的CMD命令

1.盘符名称+冒号；作用：盘符切换。
dir；作用：查看当前路径下的内容(展示所有文件、文件夹，包括隐藏文件)。
cd 目录；作用：进入单级目录(目录名字太长可以用tab键)。
cd ..；作用：回到上一级目录。
cd 目录1\目录2\...；作用：进入多级目录。
cd \；作用：回退到盘符目录。
cls；作用：清屏。
exit;作用：退出。

用cmd打开应用

最原始的方法

切换盘符
进入目录
直接输入应用名称

还可以用环境变量

将应用路径加入环境变量的Path

下载好jdk之后配置环境变量

1.打开高级系统设置中的环境变量

2.在系统变量中新建两个变量

变量名：JAVA_HOME 变量值：jdk的安装路径
变量名：CLASSPATH 变量值：.;%JAVA_HOME%\lib

3.在Path变量中新建变量

%JAVA_HOME%\bin

并将其上移至第一位

第一个JAVA程序

进入代码文本的路径
编译：javac 文档名字带后缀
运行： java 文档名字不带后缀

打印hello,world

public class hello {//类的名称要和文件名一致
    //main方法，表示程序的主入口
    public static void main(String[] args) {
        System.out.println("hello,world");
    }
}

注意区分大小写

关键字

特点：字母全是小写，在代码编辑器中有特殊颜色标记

class：用于创建、定义一个类，类是java最基本的组成单元。

字面量：数据在程序当中的书写格式

整数类型，小数类型，字符串类型，字符类型，布尔类型，空类型

printfln

字符串用双引号，字符用单引号，布尔类型不用引号，和数字一样

空类型不能打印，要用字符串类型（双引号）

\t 制表符，将字符串补齐八位或八的倍数

printfln(“name” + ‘\t’ + “age”);

printf

Java中也可以用System.out.printf(“%8d”,number);来右对齐输出数字

变量

定义格式：与C一样

类型：与C一样

哇这一段和C几乎一样欸

一样的

还是一样的

哇好神奇

注意事项也一样欸

哇写计算题也一样欸

数据类型：基本数据类型，引用数据类型

在这里插入图片描述

定义long类型的变量，要加一个L作为后缀，L可大写可小写，为了方便区分，选择大写

float类型后缀加F

其他类型不用后缀

基本数据类型转字符类型

格式：

int n = 100;
String s = n + "";

标识符

1.由数字、字母、下划线和$组成

2.不能以数字开头

3.不能是关键字

4.区分大小写

在这里插入图片描述

输出语句

System.out.println("abc");//先打印，再换行
System.out.print("abc");//只打印，不换行
System.out.println();//只换行

printf

	System.out.printf("");--C中的printf

java不能用”\n“换行，只能打印System.out.println();换行

键盘录入

scanner，就是scanf

使用规范：

	找scanner的导包(C里面的头文件)
    import java.util.Scanner
    创建对象
    Scanner sc = new Scanner(System.in);
    输入：
    第一类：遇到空格、回车、制表停止
    int i = sc.nextInt();//整数
	nextDouble();//小数
	next();//字符串
	第二类：遇到回车才停止
	nextLine();//字符串

运算符

算数运算符

提问：小数运算输出结果怎么保留几位小数

字符串的“+”：

当“+”的操作出现字符串时，“+”就是字符串连接符

并且“+”从左向右计算，如果前面的全是数字，就正常计算，遇到字符串再连接

字符相加：

查ASC码表

字符＋字符串也是拼接操作

字符串只有加的操作

逻辑运算符和关系运算符

运算符的使用与C相同

C返回的是0和1，Java返回true和false

位运算符

Java里面，左移和C一样，右移不同

“>>”表示有符号右移—符号位不变，左边补上符号位

“>>>”表示无符号右移—正常移位，补0

自增自减运算符

和C一样

赋值运算

和C一样

赋值运算的底层隐藏了一个强制类型转换，类型不一样时，将右边的转换成左边的类型

三元运算符

作用：进行判断，根据判断的结果表达不同的内容

和C一样？：；

知识回顾：原码反码补码

原码：二进制

反码：正数的补码是其本身，负数的反码符号位不变，其余位取反

补码：正数的补码是其本身，负数的补码是反码+1

判断和循环

顺序结构

从上往下依次执行

if语句

和C基本相同

注意：

大括号建议写在第一行的末尾，另起一行偶尔有bug

如果只有一句代码，大括号可以省略不写

判断布尔类型不用加“==”

在语句 int a = 100; 中，其实执行了两步：先定义变量，后赋值，此时也需要大括号

if-else 和 if-else if 同C一样

switch语句

和C大体一样

同时，存在语句：

switch(num) {
	case 1,2,3,4 -> System.out.println("");
}

高版本jdk可以使用逗号和箭头简化语句

这种语句不用写break

循环语句

for语句

和C一样

while语句

和C一样

do-while

和C一样

循环可以起名字

好神奇

在while/for前面加上名字和冒号，就给循环起了个名字，再进行break的时候，就能break 循环名；直接跳出那个循环。

开根号运算

double result = Math.sqrt(x);
System.out.println(result);

数组

概念：和C一样

定义数组：

1.数据类型[] 数组名--int []array 
2.数据类型 数组名[]--int array[]
int arr[] = new int[]{1,2,3};
int arr[] = {1,2,3};

数组也可以存储字符串

String[] array = new String[]{"first","second","third"};//完整版
String[] array = {"first","second","third"};//简化版

索引：角标、下标

在Java当中，关于数组的一个长度属性——length

调用方式：数组名.length

自动生成数组的遍历方式：

idea提供的
//数组名.fori

方法

方法：程序中最小的执行单元——联想：C中的函数

好处：

提高代码的复用性
提高代码的可维护性

方法的格式

方法定义：（C里面定义函数）
方法调用：（调用函数）
```
public static void 方法名() {
    方法体;
}
```
main方法也可以被调用！！！！
含参调用：和C一样
==注意！！==方法之间是平级关系，可以放在main方法的前面/后面，不用声明，且不可嵌套
方法的重载：同一个类中方法名相同，但参数不同的方法，且与返回值无关

在这里插入图片描述

注：顺序不同可以构成重载，但是不建议

方法的内存

Java的内存分配：堆、栈、方法区、本地方法栈、寄存器
方法调用的基本内存原理：被调用之后进栈执行
基本数据类型——数据值存储在自己的空间中
引用数据类型——空间中存储地址，数据值存储在别的空间

面向对象

类：是对象共同特征的描述

对象：真实存在的具体东西——同一类的东西

在Java中，必须先设计类，才能获得对象

如何定义类

public class 类名 {
	1.成员变量（代表属性，一般是名词）
    2.成员方法（代表行为，一般是动词）
    3.构造器
    4.代码块
	5.内部类
}

如何得到类的对象

	类名 对象名 = new 类名();
	Phone p = new Phone();

如何使用对象

访问属性:对象名.成员变量
访问行为:对象名.方法名(…)

在这里插入图片描述

一个Java文件中可以定义多个class类，且只能一个类是public修饰，public修饰的类名必须成为代码文件名

在这里插入图片描述

C语言默认初始值是乱的，没有固定值

成员变量的完整定义格式：

修饰符 数据类型 变量名称 = 初始化值;

封装

对象代表什么，就要封装对应的数据，并提供数据对应的行为

注重对象！

private 关键字——保证数据安全性

权限修饰，可以修饰成员变量和成员方法，被修饰的成员只能在本类中访问

public 关键字

公共，被修饰的成员可以在所有类访问。

set和get方法

set:给成员变量赋值——把传递进来的值赋给成员变量。

get:对外提供成员变量的值。——调用函数，返回对象的值，无需传参。

调用赋值

类名 新对象 = new 类名;
新对象.getXXX();

成员变量和局部变量

成员变量——方法外面、类的里面的变量

局部变量——方法中的变量

调用变量时，遵从就近原则——谁近用谁，局部比成员近

想用成员变量时，需要 $t h i s . 成员变量$

$t h i s 关键字$ ——调用类中的属性、表示当前对象、调用类中的方法或构造方法

构造方法——也叫构造器、构造函数

作用：在创建对象的时候，由虚拟机自动调用，给成员变量进行初始化

在这里插入图片描述

如果创建对象的时候没有写任何的构造方法，虚拟机会加一个空参构造方法

空参变量没有返回值，不用写void，直接写类名。

带参构造——创建对象的时候给对象赋值

存在带参构造时，虚拟机不会加空参构造方法。

构造方法的重载——无参构造和带参构造。

注意：无论是否使用，都要手动书写无参构造方法。

对象内存图

在这里插入图片描述

Random类——生成随机数

Random类的基本特点：

Random 类位于 java.util 包下。
当创建 Random 类的一个实例时，默认情况下会使用当前系统时间作为种子（seed），这通常可以保证每次程序运行时生成不同的随机数序列。
用户也可以通过传递一个特定的长整型种子给构造函数来初始化 Random 对象，如果两次使用相同的种子初始化，将会得到相同的随机数序列。

Random类的主要方法包括：

构造方法：
- Random()：使用当前时间作为种子初始化随机数生成器。
- Random(long seed)：使用指定的种子值初始化随机数生成器。
整数类型随机数生成方法：
- nextInt()：生成一个0（包含）到Integer.MAX_VALUE（不包含）之间的随机整数。
- nextInt(int bound)：生成一个0（包含）到bound（不包含）之间的随机整数。
长整数类型随机数生成方法（不存在直接的长整型版本，但可以通过多次调用nextInt()组合得到）。
浮点数类型随机数生成方法：
- nextDouble()：生成一个0.0（包含）到1.0（不包含）之间的随机 double 值。
- nextFloat()：生成一个0.0f（包含）到1.0f（不包含）之间的随机 float 值。

字符串

String

字符串的内容不会发生改变，值在创建好后不能更改
创建String对象

==注意：==直接赋值时，如果内存中有相同的字符串，就不会创建新字符串

从键盘输入字符串，得到的是新创建的字符串

字符串的比较

“==”作比较，如果是基本数据类型，比较值，是引用数据类型，比较地址值

字符串比较：

	str1.equals(str2);//内容必须完全一样，方法返回一个布尔类型的结果
	str1.equalsIgnoreCase(str2);//比较内容，忽略大小写，返回布尔类型

遍历字符串(查找)

	charAt(int index);//根据索引返回字符
	str.lenth();//返回字符串的长度
	indexOf(str); //查找参数字符串在本字符串中首次出现的索引位置，如果没有，返回-1

字符串拼接

实现：直接相加

或者： concat(str);

字符串的截取

	public String substring(int index);//从index位置开始截取，直到字符串末尾，返回截取的字符串
	public String substring(int begin,int end);//截取从begin到end区间的字符串，但是左闭右开区间

字符串的转换

	public char[] toCharArray();//将字符串拆分成字符数组
	public byte[] getBytes;//获得当前字符串的底层字节数组
	public String replace(目标，替换后);

分割字符串

	split(按“分割”);

StringBuilder类

可以看成是一个容器，创建之后里面的内容是可变的。

作用：提高字符串的操作效率。

构造方法：空参和实参。

常用方法：

public StringBuilder reverse();//反转
public StringBuilder append(任意类型) //添加数据，返回对象本身。
public int length(); //返回长度（字符出现的个数）
public String toString();//实现把StringBuilder转换为String;

StringJoiner类

也可以看成是一个容器，创建之后里面的内容是可变的。

作用：提高字符串的操作效率，代码编写特别简洁。

构造方法：两个带参构造

public StringJoiner(间隔符号) //创建一个SJ对象，指定拼接时的间隔符号
public StringJoiner(间隔符号，开始符号，结束符号) //...指定间隔符号、开始符号、结束符号

成员方法：

public StringJoiner add(添加的内容) //添加数据，返回对象本身。
public int length() //返回长度
public String toString() //返回一个字符串（拼接后的结果）

链式编程：当我们调用一个方法的时候，不需要用变量接收他的结果，可以继续调用其他方法

集合

和数组的区别：

集合只能存储引用数据类型，不能存储基本数据类型，需要将基本数据类型转为包装类。
数组长度固定，集合长度可变。

ArrayList——增删改查
- 创建对象
  泛型：限定集合中存储数据的类型。
```
	ArrayList<String> list = new ArrayList<>();
```
  注意：集合的打印对象不是地址值，而是集合中存储的数据内容，展示的时候会拿[ ]把所有的数据进行包裹。
- 添加元素
```
	list.add();
```
- 删除
```
	list.remove("元素");
	list.remove(index);//返回被删除的元素
	String str = list.remove(2);
```
- 修改
```
	list.set(index,"");//返回被覆盖的元素
```
- 查询
```
	list.get(index);
```
- 获取长度
```
	list.size();//返回int
```

static关键字——共享信息

静态变量——static修饰的成员变量

静态变量优先于对象出现，随着类的加载而加载。

在这里插入图片描述

静态方法——static修饰的成员方法
- 工具类——帮助做事，但是不描述任何事物的类。
- 类名见名知意、私有化构造方法、方法定义为静态。
- 静态方法中，只能访问静态。
- 非静态方法可以访问所有。
- 静态方法中没有this关键字。

继承

封装：对象代表说明，就得封装对应的数据，并提供数据对应的行为。

继承

关键字：extends——让一个类和另一个类建立起继承关系。

例如：

public class Student extends Person{}

其中，Student称为子类（派生类），Person称为父类（基类或超类）。

好处：

可以把子类的重复代码抽取到父类，提高代码的复用性
子类可以在父类的基础上增加其他的功能，使子类更强大

什么时候用继承：类与类之间存在共性内容，并满足子类是父类的一种。

特点：Java只支持单继承，不支持多继承，但支持多层继承

单继承：一个子类继承一个父类

多继承：子类不能同时继承多个父类

多层继承：A继承B，B继承C（C是A的间接父类）

每一个类都直接或间接的继承于Object——如果没有extends，虚拟机默认继承Object。

子类对父类的继承

构造方法：非私有——不能继承；私有——不能继承。

成员变量：非私有——能继承；私有——能继承。（私有不能调用但是能继承）

成员方法：非私有——能；私有——不能。

构造方法——不能继承（原因：继承之后，构造方法的名字和子类不同，不符合构造方法的规则。

方法执行的时候，会设立虚方法表（非private、static、final)

继承的语法特点

成员变量的访问特点
- 就近原则。从局部变量->本类的成员变量->父类的成员变量
- 成员变量重名：局部（直接调用）本类成员（this)父类成员（super)
- super关键字——调用父类的成员变量，用法同this
成员方法的访问特点
- 就近原则
- this、super
构造方法的访问特点
- 父类中的构造方法不会被子类继承。
- 子类中所有构造方法默认先访问父类中的无参构造，再访问自己。——子类初始化的时候有可能会用到父类中的数据。
- 子类初始化前，一定要调用父类构造方法，先完成父类数据空间的初始化。
- 子类构造方法的第一行语句默认都是super();不写也会被虚拟机加上，且必须在第一行。调用父类的空参构造。
- 如果想调用父类的有参构造，必须手写super进行调用。super(参数，参数);

方法的重写

当父类的方法不能满足子类的需求时，需要进行方法重写

格式：在继承体系中，子类出现的和父类中一模一样的方法声明

重写注解： $@ O v e r r i d e$ ——给程序员和虚拟机看的注释，校验子类重写时语法是否正确。加在重写方法的上面。加上注解后如果有红色波浪线，则表示语法错误。

本质：子类的虚方法表：在B的基础上添加自己类中的虚方法，如果发生了重写，则会覆盖父类的虚方法。

注意：

重写方法的名称、形参列表必须和父类中一致。
重写时，访问权限子类必须大于等于父类（空着不写<protected<public)
重写时，返回值类型子类必须小于等于父类。
建议：重写的方法尽量和父类保持一致。
只有被添加到虚方法表中的方法才能被重写。

this、super

this:理解为一个（局部）变量，表示当前方法调用者的地址值。
super:代表父类的存储空间。
在空参中用this()调用本类其他构造方法，虚拟机就不会添加super();this()应写在第一行。

多态

同类型的对象，表现出的不同形态。

表现形式：

父类对象 对象名称 = 子类对象;
Person stu = new Student();

前提：

有继承关系
有父类引用指向子类对象
有方法重写

多态调用成员

变量调用：编译看左边，运行也看左边。（父类中有变量才会编译成功，运行时实际获取的就是左边父类中成员变量的值）
方法调用：编译看左边，运行看右边。（调用父类中没有的方法时，要类型转换，如：Dog d = (Dog) a ;且类型转换只能存在于创建的对象和父类中，不然会报错）

instanceof

判断变量是不是某个类型

变量 instanceof 类

返回true/false

包和final

包：文件夹，管理不同功能的java类

包起名的规则：公司域名反写+包的作用，英文小写——package关键字

包名+类名=全类名/全限定名。

使用其他类的时候，需要用全类名。

import关键字

作用：导包

使用其他类的规则

在这里插入图片描述

final关键字

最终的、不可变的

修饰方法——方法是最终方法，不能被重写。
修饰类——该类是最终类，不能被继承。
修饰变量——变量变常量，只能被赋值一次。
修饰基本数据类型，变量存储的值不能发生改变。
修饰引用数据类型，变量存储的地址值不能发生改变。对象内部可以改变。

权限修饰符

代码块

局部代码块（仅了解）

写在方法里面的大括号

作用：提前结束变量的生命周期，节约内存。

构造代码块

写在成员位置的代码块
作用：可以把多个构造方法中重复的代码抽取出来
执行时机：优先执行构造代码块，再执行构造方法。
缺点：不够灵活
优化：当多个构造方法里有重复代码时，可将重复代码写成方法，也可写到一个构造方法里，用this调用。

静态代码块

格式：static{}
特点：需要通过static关键字修饰，随着类的加载而加载，自动触发，只执行一次
使用场景：类加载时，需要数据初始化的时候

抽象类和抽象方法

抽象方法：将共性的行为（方法）抽取到父类之后，由于每一个子类执行的内容不一样，在父类中不能确定具体的方法体，该方法就可以定义为抽象方法。——需要重写的方法，抽象方法子类不重写会报错
抽象类：一个类中存在抽象方法，该类必须被定义为抽象类
定义格式：

抽象方法：public abstract 返回值类型 方法名（参数）;
抽象类：public abstract class 类名{}

注意事项：
- 抽象类不能创建对象
- 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
- 抽象类可以有构造方法（创建子类对象时，给属性进行赋值）
- 抽象类的子类——如果子类不是抽象类，必须重写抽象类中的所有抽象方法
意义：强制子类重写，便于统一。

接口

理解为一种规则，子类必须按照它的形式写。

定义和使用

关键字interface_public interface 接口名{}
接口不能实例化（不能创建对象）接口和类之间时实现关系，用 $i m p l e m e x t s$ 关键字表示

public class 类名 implements
接口的子类（也叫实现类）

要么重写接口中的所有抽象方法，要么是抽象类。
接口和类是实现关系，一个类可以实现不只一个接口

public class 类名 implemexts 接口名1，接口名2{}
实现类还可以在继承一个类的同时实现多个接口

public class 类名 extends 父类 implements 接口名1，接口名2 {}

接口中成员的特点

成员变量

只能是常量

默认修饰符： $p u b l i c$ static final
没有构造方法——接口不用创建对象
成员方法：

只能是抽象方法

默认修饰符：public abstract
JDK7以前——接口中只能定义抽象方法

JDK8——可以定义有方法体的方法

JDK9——可以定义私有方法

接口和类的关系

类和类的关系

继承关系，只能单继承，不能多继承，可以多层继承
类和接口的关系

实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口。多个接口中有重复方法，只用重写一次。
接口和接口的关系

继承关系，可以单继承，也可以多继承。

如果实现类实现了最下面的子接口，就需要重写所有的抽象方法。

内部类

概念：在一个类里面，再定义一个类

一个类里面定义的类是内部类，外面的类叫外部类，其他的类叫其他外部类。

注意：

内部类表示的事物是外部类的一部分
内部类单独出现没有任何意义

内部类的访问特点：

内部类可以直接访问外部类的成员，包括私有。
外部类要访问内部类的成员，必须创建对象。

成员内部类

概念：写在成员位置的，属于外部类的成员。
成员内部类可以被一些修饰符所修饰，比如：private，默认，protected，public，static等静态内部类
JDK16之后才可以在成员内部类中定义静态变量。
获取成员内部类对象：
- 方法一：在外部类中编写方法，对外提供内部类的对象。——写一个get方法，返回内部类对象，一般在内部类私有时使用这个方法。
- 方法二：直接创建，格式：外部类名.内部类名对象名 = new 外部类对象.new 内部类对象;
内部类如何获取外部成员对象：
- 外部类类名.this.成员变量
静态内部类
- 用static修饰的成员内部类
- 静态内部类只能访问外部类中的静态变量和静态方法，想要访问非静态需要创建对象。
- 创建静态内部类对象的格式：外部类名.内部类名对象名 = new 外部类名.内部类名();
- 调用非静态方法的格式：先创建对象，再对象调用
- 调用静态方法的格式：外部类名.内部类名.方法名();

局部内部类

将内部类定义在方法里面就叫局部内部类，类似于方法里面的局部变量。
外界无法直接使用，需要在方法里面创建对象。
可以直接访问外部类的成员，也可以访问方法内的局部变量。

匿名内部类

本质就是隐藏了名字的内部类，可以写在成员位置，也可以写在局部位置

格式：

new 类名或接口名() {  //继承/实现关系
	重写方法;  //方法重写
};  //创建对象

整体是一个类的子类对象或者接口的实现类对象，大括号里面的是类
使用场景：当方法的参数是接口或类时，可以传递实现/继承类的对象，如果实现/继承类只用一次，就可以用匿名内部类简化代码。

集合进阶

集合体系结构

单列集合——Collection

在这里插入图片描述

ps:Vector已经被淘汰，很少使用

List系列集合：添加的元素是有序、可重复、有索引的；
- 有序——存取的东西一样，不是排序。
Set系列集合：添加的元素无序、不重复、无索引。
Collection
- 是一个接口，不能直接创建它的对象，只能创建它实现类的对象。
- 它的功能是全部单列集合都可以继承使用的。
- 常见方法：
- Collection里面定义的是共性的方法，所以不能通过索引删除·

System类

标准输入/输出流：

	System.in: 表示标准输入流，通常关联到控制台的键盘输入。
	System.out: 默认的标准输出流，用于向控制台输出数据，常配合println()和print()方法使用。
	System.err: 表示标准错误输出流，用于显示错误信息。
	输出方法：

	public static void println(String x): 将字符串x换行后打印到标准输出流。
    public static void print(String x): 将字符串x打印到标准输出流，不换行。
	获取系统时间：

	public static long currentTimeMillis(): 返回当前时间与1970年1月1日0点0分0秒（UTC）之间的毫秒数。
	清理系统资源：

	public static void gc(): 请求系统进行垃圾回收，但并不保证立即执行。
	复制数组部分：

	public static native void arraycopy(Object src, int srcPos, Object dest, int destPos, int length): 将源数组的一部分复制到目标数组中。
	设置或获取系统属性：

	public static String getProperty(String key): 获取系统属性值。
	public static void setProperty(String key, String value): 设置系统属性值。
	其他与系统相关操作：
	
	public static void exit(int status): 终止当前正在运行的Java虚拟机，status参数通常作为退出状态码。
	public static void setIn(InputStream in), setOut(PrintStream out), setErr(PrintStream err): 重定向标准输入、标准输出和标准错误流。

个接口，不能直接创建它的对象，只能创建它实现类的对象。
- 它的功能是全部单列集合都可以继承使用的。
- 常见方法：
- [外链图片转存中…(img-P5fVpwOw-1716728383238)]
- Collection里面定义的是共性的方法，所以不能通过索引删除·

System类

标准输入/输出流：

	System.in: 表示标准输入流，通常关联到控制台的键盘输入。
	System.out: 默认的标准输出流，用于向控制台输出数据，常配合println()和print()方法使用。
	System.err: 表示标准错误输出流，用于显示错误信息。
	输出方法：

	public static void println(String x): 将字符串x换行后打印到标准输出流。
    public static void print(String x): 将字符串x打印到标准输出流，不换行。
	获取系统时间：

	public static long currentTimeMillis(): 返回当前时间与1970年1月1日0点0分0秒（UTC）之间的毫秒数。
	清理系统资源：

	public static void gc(): 请求系统进行垃圾回收，但并不保证立即执行。
	复制数组部分：

	public static native void arraycopy(Object src, int srcPos, Object dest, int destPos, int length): 将源数组的一部分复制到目标数组中。
	设置或获取系统属性：

	public static String getProperty(String key): 获取系统属性值。
	public static void setProperty(String key, String value): 设置系统属性值。
	其他与系统相关操作：
	
	public static void exit(int status): 终止当前正在运行的Java虚拟机，status参数通常作为退出状态码。
	public static void setIn(InputStream in), setOut(PrintStream out), setErr(PrintStream err): 重定向标准输入、标准输出和标准错误流。

卡尼杉纳

关注

33
点赞
踩
30

收藏

觉得还不错? 一键收藏
打赏
0
评论
从零开始学Java

关键字interface_public interface 接口名{}接口不能实例化（不能创建对象）接口和类之间时实现关系，用implemextsimplemextsimplemexts关键字表示public class 类名 implements接口的子类（也叫实现类）要么重写接口中的所有抽象方法，要么是抽象类。接口和类是实现关系，一个类可以实现不只一个接口public class 类名 implemexts 接口名1，接口名2{}
复制链接

扫一扫