Java总结-2019.10
作者:互联网
节点1:环境搭建,Java基础语法
1. 环境搭建
版本:
J2SE、J2EE、J2ME
下载并安装JDK
JDK(Java Develop Kit):开发工具包
JRE(Java Runtime Environment):运行时环境
配置环境变量
右键—>计算机—>选择“属性”—>点击“高级系统设置”—>打开“系统属性”窗口—>点击“环境变量”
(1) 新建“JAVA_HOME”环境变量,值设置为:JDK的安装目录
(2) 修改“Path”环境变量,添加“;%JAVA_HOME%\bin;”
(3) Classpath(可选)
验证是否安装成功:
打开“运行”—>输入cmd—>在命令提示符窗口,输入java –version,如果能够出现如下界面,则安装成功!
2. 第一个Java程序
创建文件名为HelloWorld.java的源文件:
//定义一个公共类,类名HelloWorld
public class HelloWorld{
//类体-main方法
public static void main(String[] args){
//方法体
System.out.print("Hello World!");
}
}
运行Java程序:
(1) 打开“运行”,输入cmd,打开命令提示符窗口
(2) 切换目录
a) 切换盘符: e:
b) 切换目录: cd billfox(cd—change directory)
c) 编译程序: javac HelloWorld.java(编译源文件,获得class字节码文件)
d) 运行程序: java HelloWorld(运行字节码文件)
3. 开发工具的安装使用
安装版.exe
解压版
4. 使用Eclipse创建Java项目
包名:反域名制(com.taobao.projectName)
类名:所有单词首字母要大写!(UpperCamelCase驼峰命名法 StudentCount)
变量名,方法名,参数名:(lowerCamelCase驼峰命名法 studentCount)
常量:所有字母大写,每个单词之间用下划线隔开。 MAX_STOCK_COUNT
命名规范:由字母,数字,下划线和$组成,不能以数字开头。
比如:num1 num_1 $num
5. Java编程基础
1) 变量
语法:数据类型 变量名 [= 值];
例子:int count = 10;
float studentWeight;
标识符和关键字
标识符:是用来表示变量名、类名、方法名、数组名和文件名的有效字符序列。
关键字:是Java语言中被赋予特定含义的一些单词。
变量的作用域
public class Demo01 {
public static void main(String[] args) {
//变量的作用域
int x = 10;
{
//代码块
int y = 20;
System.out.println(y);
System.out.println(x);
}
System.out.println(y);//报错,超出了y的作用范围
System.out.println(x);
}
}
2) 数据类型( 四类8种)
(1) 整数型
a) 字节型byte 1个字节(8位) -27 ~27-1
b) 短整型short 2个字节(16位) -215 ~215-1
c) 整型int 4个字节(32位) -231 ~231-1
d) 长整型long 8个字节(64位) -263 ~263-1
(2) 浮点数类型
a) 单精度浮点 float 4个字节
b) 双精度浮点 double 8个字节
(3) 布尔型 boolean (true,false)
(4) 字符型 char
数据类型转换
(1) 自动类型转换(小 转 大)
byte–>short–>char–>int–>long–>float–>double
例子:
int num = 20;
float f1 = num;
(2) 强制类型转换(大 转 小)
例子:
float f2 = 2.5f;
int num2 = (int)f2;//有可能损失精度或者溢出
(3) 字符串型数据和整型数据相互转换 “10” 10
a) 字符串 转 数字 int num = Integer.parseInt(“10”);
b) 数字 转 字符串 String str = 10 + “”;
3) 输入输出
输出:
System.out.print(输出的内容); //不换行
System.out.println(输出的内容); //输出内容后换行
输入:
Scanner sc = new Scanner(System.in);//简易的文本扫描器
int I = sc.nextInt();//获取输入的整数
float f = sc.nextFloat();//获取输入的单精度浮点数
double d = sc.nextDouble();//获取输入的双精度浮点数
String s = sc.next();//获取输入的字符串
代码提示配置
参考https://www.cnblogs.com/zgqys1980/p/5067337.html
主动触发代码提示的快捷键:Alt + /
字体大小配置
Window->preferences->搜索”font”->选择”Colors and Fonts”->选择右侧列表中Basic下的Text Font,然后点击编辑(Edit)按钮,修改你想要的字体大小即可。
4) 常量
符号常量:final double PI = 3.1415926;
字面常量:10、2.5、’a’
5) 运算符
1. 算术运算符
+、-、*、/、%、++(前/后)、–(前/后)
注意:
/ 当两个运算数为整数时,为取整运算。
/ 当两个运算符不全为整数时,为除法运算。
c = a++;//先把a的值赋给c,然后a再自增
c = ++a;//先把a的值自增,然后把a赋给c
2. 关系运算符
、<、>=、<=、==、!=
由关系运算符构成的关系表达式,返回值为布尔值,即true/false.
3. 逻辑运算符
&&(短路与)、||(短路或)、!、&(非短路与)、|(非短路或)、^(异或)
逻辑运算符,用于连接关系表达式(boolean),最终的结果,也是布尔值(boolean)。
4. 位运算符
5. 赋值运算符
=、+=、-=、*=、/=、%=
a += 10;// 等价于 a = a + 10;
6. 条件运算符
表达式1?表达式2:表达式3;
“表达式1”是一个结果为布尔值的逻辑表达式。也就是返回值为true/false
运算规则:
如果表达式1返回true,则整个表达式的返回值为表达式2;否则返回表达式3;
7. 字符串运算符
其实就是对字符串进行拼接。
8. 运算符的优先级
. [] ()
算术运算符
关系运算符
逻辑运算符
条件运算符
赋值运算符
6) 流程控制语句
1. 顺序结构
2. 分支结构
- 单分支if
- 双分支if…else…
- 多分支
a) If…else if…else if…else
b) Switch(表达式){case 值1:break; default:break;} - 分支结构嵌套
3. 循环结构
- While
- Do…while
- For
- Foreach增强for循环
4. 跳转语句
break;//结束循环
continue;//退出本次循环,进入下一次
return;//退出方法
7) 数组
1. 数组的定义
(1)int[] scores;//声明
scores = new int[45];//初始化
(2)int[] scores = new int[45];//声明数组的同时初始化
(3)静态初始化
int[] arr = new int[] {1,2,3,4,5,6};
int[] arr = {1,2,3,4,5,6};
2. 数组的赋值
scores[0] = 10;
scores[1] = 15;
3. 数组的常用操作
数组遍历
数组最值(最大值,最小值)
数组排序(冒泡排序,选择排序)
数组元素的删除,修改
4. Arrays
排序 sort
查询 binarySearch
复制 copyOf
转字符串 toString
填充 fill
8) 方法
1. 方法的定义
[修饰符] 返回值类型 方法名([参数类型 参数名1,参数类型 参数2…]){
//方法体
}
例子:
public static void printStar(int line,int column) {
for(int i = 0;i < line;i++) {
//打印第i行:
//打印j个星号
for(int j=0;j<column;j++) {
System.out.print("*");
}
//打印换行
System.out.println();
}
}
2. 方法的分类
(1) 无返回值无参数
public class Demo02 {
public static void main(String[] args) {
welcome();
}
public static void welcome() {
System.out.println("**************");
System.out.println("*** 欢迎光临 ***");
System.out.println("**************");
}
}
(2) 无返回值有参数
public class Demo03 {
public static void main(String[] args) {
welcome("Hello");
}
public static void welcome(String content) {
System.out.println("**************");
System.out.println("*** "+content+" ***");
System.out.println("**************");
}
}
(3) 有返回值无参数
public class Demo04 {
public static void main(String[] args) {
int num = getNum();
//System.out.println(num);
}
//有返回值
public static int getNum() {
//创建随机类
Random rad = new Random();
//int n = rad.nextInt(); //获得一个随机数
int n = rad.nextInt(); //获得一个bound范围之内的随机数, 10 [0,10) n>=0 n<10
return n;
}
}
(4) 有返回值有参数
public class Demo05 {
public static void main(String[] args) {
int sum = add(8, 5);
System.out.println(sum);
}
//加法
public static int add(int n1,int n2) {
int result = n1 + n2;
return result;
}
}
节点2:Java面向对象编程
- 面向对象编程思想
与面向过程编程思想的区别:
可以拿生活中的实例来理解面向过程与面向对象,例如五子棋,面向过程的设计思路就是首先分析问题的步骤:1、开始游戏,2、黑子先走,3、绘制画面,4、判断输赢,5、轮到白子,6、绘制画面,7、判断输赢,8、返回步骤2,9、输出最后结果。把上面每个步骤用不同的方法来实现。
如果是面向对象的设计思想来解决问题。面向对象的设计则是从另外的思路来解决问题。整个五子棋可以分为1、黑白双方,这两方的行为是一模一样的,2、棋盘系统,负责绘制画面,3、规则系统,负责判定诸如犯规、输赢等。第一类对象(玩家对象)负责接受用户输入,并告知第二类对象(棋盘对象)棋子布局的变化,棋盘对象接收到了棋子的变化就要负责在屏幕上面显示出这种变化,同时利用第三类对象(规则系统)来对棋局进行判定。
2. 类和对象的概念:
• 对象:对象是类的一个实例(对象不是找个女朋友),有状态和行为。例如,一条狗是一个对象,它的状态有:颜色、名字、品种;行为有:摇尾巴、叫、吃等。(具体)
• 类:类是一个模板,它描述一类对象的行为和状态。(抽象)
3. 类的设计
- 类的构成:
1) 成员变量
2) 成员方法
3) 构造方法
特点:
1.构造方法的方法名必须和类名一致。
2.没有返回值类型。
4) 类成员
类变量(静态变量) 访问: 类名.类变量
类方法(静态方法) 访问: 类名.类方法()
静态代码块
/*
-
类的设计
-
1)成员变量
-
2)成员方法
-
3)构造方法
-
4)类成员
-
a.类变量
-
b.类方法
-
c.静态代码块
-
类,其实一种用户自定义的数据类型。
-
编码规范:驼峰命名法
*/
public class Student {//1.成员变量
String name;
String sex;
int age;//2.成员方法
public void study() {
System.out.println(name+“在学Java,在”+school);//成员方法可以访问类变量,但类方法不能访问成员变量。
}public void playGame() {
System.out.println(name+“在玩王者荣耀”);
}//3.构造方法
/*- 特点:
- 1.构造方法的方法名要和类名一致。
- 2.没有返回值类型。
- —3.一般情况下,用public来修饰。
*/
public Student() {
System.out.println("–构造方法执行–");
count++;
}
////////////////////////////////////////////////////////////////////////////////
//4.类变量(静态变量)
static String school;
static int count;//当前类的对象个数//5.类方法(静态方法)
public static void count() {
System.out.println(“学校共有”+ count+“个学生 。”);
}//6.静态代码块
static {
//对类进行初始化
count = 0;
System.out.println("–学校构建完成。–");
}
}
- 参数的传递(值传递)
基本数据类型:变量值
引用数据类型:内存值
了解:InstanceOf:判断某个对象是否是某个类的对象。 S1 instanceof Student
- 方法重载
方法重载的特点:
-
在同一个类中
-
方法名相同
-
参数的个数或者类型不同
public class Actor {
String name;//表演
public void act() {
System.out.println(“唱歌”);
}public void act(String instrument) {
System.out.println(“边弹” + instrument +“边唱”);
}public void act(int n) {
System.out.println(“循环唱” + n +“次”);
}
}方法重载,包括:
-
成员方法重载
-
构造方法重载。
public class Actor {
//成员变量
String name;
String sex;
int age;//成员方法 重载
public void act() {
System.out.println(“唱歌”);
}public void act(String instrument) {
System.out.println(“边弹” + instrument +“边唱”);
}public void act(int n) {
System.out.println(“循环唱” + n +“次”);
}//构造方法 重载
public Actor() {
}public Actor(String actorName) {
name = actorName;
}public Actor(String actorName,String actorSex) {
name = actorName;
sex = actorSex;
}public Actor(String actorName,String actorSex,int actorAge) {
name = actorName;
sex = actorSex;
age = actorAge;
}
}补充:可变参数
//求整数的和(可变参数)
public int add(int… nums) {
int sum = 0;
for (int i = 0; i < nums.length; i++) {
sum = sum + nums[i];
}
return sum;
}
-
this
this指当前类的对象
public Actor(String name,String sex,int age) {
this.name = name;//当前要创建的对象的name属性 = name参数;
this.sex = sex;
this.age = age;
}
通过this关键字
1.可以调用当前类的成员变量。
2.可以调用当前类的成员方法。
3.可以调用当前类的构造方法。
public class Student {
String name;
String sex;public void study() {
System.out.println(this.name+“在学习”);//1.通过this调用成员变量
}public void race() {
this.study();//2.通过this调用成员方法
System.out.println(“参加比赛!”);
}public Student() {
}
public Student(String name){
this();//3.通过this调用无参构造
this.name = name;
}
}
节点3:封装,继承,多态
-
封装
实现步骤:
(1)属性私有化 (2)提供公共的getter,setter方法
自动生成get,set方法:右键—>Source—>Generate Getters and Setters
public class Actor {
//成员变量
private String name;
private String sex;
private int age;
//提供公共的get,set方法
public void setName(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
public void setSex(String sex) {
if (sex.equals("男") || sex.equals("女")) {
this.sex = sex;
}else {
System.out.println("您设置的性别有误!");
}
}
public String getSex() {
return this.sex;
}
public void setAge(int age) {
if (age < 0 || age > 130) {
System.out.println("您设置的年龄有误!");
}else {
this.age = age;
}
}
public int getAge() {
return this.age;
}
//成员方法 重载
public void act() {
System.out.println("唱歌");
}
public void act(String instrument) {
System.out.println("边弹" + instrument +"边唱");
}
public void act(int n) {
System.out.println("循环唱" + n +"次");
}
//构造方法 重载
public Actor() {
}
public Actor(String name) {
this.name = name;
}
public Actor(String name,String sex) {
this.name = name;
this.sex = sex;
}
public Actor(String name,String sex,int age) {
this.name = name;
this.sex = sex;
this.age = age;
}
}
2. 继承
- 继承的概念:
可以基于已经存在的类构造一个新类。继承已经存在的类就可以复用这些类的方法和域。在此基础上,可以添加新的方法和域,从而扩充了类的功能。
继承的关键字:extends
- 继承的特点:
- 可以实现代码的复用—子类拥有父类非私有的属性和方法。
- 子类可以对父类进行扩展—子类可以拥有自己的属性和方法。
- 方法重写—子类可以用自己的方式去实现父类的方法。
- 单继承,可以多重继承
- 缺点:提高了代码的耦合度。
例子:
定义父类:
public class Animal {
//父类定义子类共有的属性和行为
String name;
String sex;
int age;
String color;
public void eat() {
System.out.println(name + "吃东西");
}
}
定义子类-Cat:
public class Cat extends Animal{
//猫类特有的行为
public void catchMouse() {
System.out.println(name+ “抓老鼠…”);
}
}
定义子类-Dog:
public class Dog extends Animal {
//狗类特有的行为
public void guard() {
System.out.println(name + “看家”);
}
}
3) 修饰符
(1) 访问修饰符
a) public:所有类都可以访问。 (当前类,同一个包中的不同类,不同包的类)
b) protected:包的访问权限+不同包的子类 (当前类,同一个包中的不同类,不同包的子类)
c) 缺省:包的访问权限。 (当前类,同一个包中的不同类)
d) private:当前类 (当前类)
(2) 非访问修饰符
a) static
i. 修饰成员变量,则成员变量变为类变量。static String school = “莱职”;
ii. 修饰成员方法,则成员方法变为类方法。
iii. 修饰代码块,则代码块变为静态代码块。特点:是在main方法之前运行,而且只运行一次。其实就是在类加载时运行。
b) final
i. 修饰变量,则变量变成不可改变的量,即常量。 final int num = 10;
ii. 修饰方法,则方法变为不可重写的方法。
iii. 修饰类,则类变为不可继承的类。
c) abstract 抽象
4) 方法重写
特点:
1.要有继承,重写发生在两个类之间,子类去重写父类的同名的方法
2.子类的方法名要和父类的方法名相同,而且参数(个数,类型)也要完全一致。
3.子类对方法的修饰,只能扩大,不能缩小。
父类:
public class Animal {
//域(成员变量)
String name;
String sex;
int age;
String color;
//方法(成员方法)
public void eat() {
System.out.println(name + "吃东西");
}
}
子类:
public class Cat extends Animal{
//特有的行为(扩展)
public void catchMouse() {
System.out.println(name+ “抓老鼠…”);
}
//子类可以重写从父类继承而来的方法
public void eat() {
System.out.println(name+"吃鱼");
}
}
-
Super
Super:指的是当前对象的父类
public class Dog extends Animal {
//特有的行为(扩展)
public void guard() {
System.out.println(name + “看家”);
}//方法重写 — 注解
@Override
public void eat() {
super.eat();//调用超类(父类)的eat方法
System.out.println(super.name+“啃骨头”);//调用超类(父类)的name属性
}
}
通过super关键字
1.可以调用父类的成员变量 super.property;
2.可以调用父类的成员方法 super.method();
3.可以调用父类的构造方法 super();
注意:子类默认会调用父类的无参构造,如果显式的调用了父类的有参构造,则不会再调用父类的无参构造。
- 多态
多态的三个必要条件:
1.继承
2.重写
3.父类引用指向子类对象(上转型对象)
节点4:抽象类和接口
- 抽象类
- 定义抽象类:
abstract class Person{
//可以包含抽象方法
}
class Student extends Person{
//子类继承抽象类,要去重写父类的抽象方法。
}
- 特点:
1.抽象类不一定包含抽象方法,但包含抽象方法的类,一定是抽象类。
- 抽象类中的抽象方法只是声明,不包含方法体,就是不给出方法的具体实现也就是方法的具体功能。
3.抽象类不能实例化。
4.抽象类只能作为子类的超类(父类),被用来创建继承层级里子类的模板。
5.Java中只有单继承。 - 构造方法,类方法(用 static 修饰的方法)不能声明为抽象方法。
- 抽象类的子类必须给出抽象类中的抽象方法的具体实现,除非该子类也是抽象类。
抽象类存在的意义,就是被继承。 - 接口
- 语法 :
[可见度] interface 接口名称 [extends 其他的接口名] {
// 声明变量
// 抽象方法
}
示例:
/*
- 1.普通类
- 只能包含非抽象方法。
*/
public class Student {
//属性
String name;
String sex;
int age;
//方法
public void study() {
System.out.println(“学习”);
}
}
/*
- 2.抽象类
- 可以包含抽象方法,非抽象方法,也可以不包含任何方法。
*/
public abstract class Animal {
//属性
String name;
//方法
public abstract void eat();
public void bark() {
System.out.println("叫。。。");
}
}
/*
- 3.接口
- 只能有抽象方法。
*/
public interface Work {
//属性(默认用public static final修饰)
int count = 0;//注意:接口中的静态常量,一定要赋初值。
//方法(默认用public abstract修饰)
void work();//抽象方法前的public abstract修饰符可以省略
public abstract void earnMoney();
}
-
接口的实现:
public class Teacher implements Work {@Override
public void work() {
System.out.println(“上课”);
}@Override
public void earnMoney() {
System.out.println(“拿课时费”);
}
}
3) 特点:
抽象类是一种特殊的类。接口是一种特殊的抽象类。
接口是一个抽象方法的集合。、
Java中,对于类来说,只有单继承,但对于接口来说,可以多继承。
定义接口的关键字:interface
- 标记接口
标记接口是没有任何方法和属性的接口.它仅仅表明它的类属于一个特定的类型,供其他代码来测试允许做一些事情。
标记接口作用:简单形象的说就是给某个对象打个标(盖个戳),使对象拥有某个或某些特权。
示例:
package java.util;
public interface EventListener {}
节点5:Object类和常用API
- Object
Object类是所有类的父类。
- 常用方法:
(1) hashcode() 返回哈希值
(2) equals() 判断对象是否相等
自动生成方式:在代码中,右键,选择”source”->”Genareate hashcode() and equals()”
(3) getClass() 返回此Object的运行时类。
(4) toString() 返回对象的字符串形式
自动生成方式:在代码中,右键,选择”source”->”Genareate toString() ”
- String(不可变性)
-
创建字符串(构造方法)
(1) String str0 = “Hello”;//字符串常量
(2) String str1 = new String(“Hello”);//通过String构造方法
(3) String str2 = new String(char[] cs);//通过字符数组构造字符串
了解String的11种构造方法 -
操作字符串(常用方法)
(1) charAt(int index) 返回指定索引处的字符
(2) indexOf(String s) 查找字符在字符串中第一次出现的位置
(3) lastIndexOf(String) 查找字符在字符串中最后一次出现的位置
(4) contains(String s) 判断是否包含字符序列
(5) substring(int beginIndex)
从beginIndex位置截取子字符串,一直扩展到字符串末尾
(6) substring(int beginIndex,int endIndex) [begin,end)
从beginIndex位置截取子字符串,一直到endIndex位置,不包括endIndex.
(7) trim() 去除前后空格!
(8) replace(char oldChar,char newChar) 替换
(9) split(String s) 字符串分割
(10) equals() 判断字符串内容是否相同
(11) equalsIgnoreCase() 忽略大小写判断相等
(12) matches(正则表达式)
(13) length() 返回字符串的字符数(长度)
(14) isEmpty() 判断字符串是否为空字符串
(15) static valueOf(各种数据类型) 返回各种数据类型的字符串形式
(16) toCharArray() 字符串 转 字符数组
(17) getBytes() 字符串 转 字节
(18) toLowerCase() 转小写
(19) toUpperCase() 转大写
(20) concat() 字符串拼接 +
(21) format() 格式化字符串 %f %d %s -
正则表达式
(1)匹配位置
^ 匹配字符串开始的位置。
$ 匹配字符串结束的位置。
(2)匹配字符
.(点号) 匹配任意一个字符
\ 将下一字符标记为特殊字符
\s 匹配任意空白字符(空格,\f换页符\n换行符\r回车符\t制表符\v垂直制表符)
\S 匹配任意非空白字符
\d 匹配任意数字
\D 匹配非数字
\w 匹配任何字类字符。等价于[A-Za-z0-9_]
\W 匹配任何非字类字符。等价于[^A-Za-z0-9_]
(3)匹配字符范围
x|y 匹配x或y.
[xyz] 匹配包含的任一字符。
[^xyz] 匹配未包含的任一字符。
[a-z] 匹配字符范围。
[^a-z] 匹配反向范围字符
(4)匹配次数-
匹配前面的字符1-n次
-
匹配前面的字符0-n次
? 匹配前面的字符0-1次
{n} 匹配前面的字符正好n次
{n,} 匹配前面的字符至少n次
{n,m} 匹配前面的字符至少n次,至多m次。总结:正则表达式,可以用于匹配matches(),替换replace()和分割split()。
-
-
StringBuffer 、StringBuilder
StringBuffer sBuffer = new StringBuffer(“Hello”);
System.out.println(sBuffer);
sBuffer.append(“World!”); //在末尾追加字符 //0123456789
System.out.println(sBuffer); //HelloWorld!
sBuffer.delete(3, 5); //删除多个字符(指定范围) [3,5)
System.out.println(sBuffer); //HelWorld!
sBuffer.deleteCharAt(0);//删除单个字符(指定位置)
System.out.println(sBuffer);//elWorld!
sBuffer.insert(2, “123456”);//在指定位置,插入内容
System.out.println(sBuffer);//el123456World!
sBuffer.reverse();//倒序
System.out.println(sBuffer);
sBuffer.setCharAt(0, ‘A’);//修改指定位置的字符
System.out.println(sBuffer);
StringBuffer中包含很多自己特有方法,也包含一些类似String类中的方法。比如(subString,indexOf,charAt)
StringBuilder和StringBuffer的方法,基本完全相同。
总结:
String:适用于少量的字符串操作的情况
StringBuilder:适用于单线程下在字符缓冲区进行大量操作的情况
StringBuffer:适用多线程下在字符缓冲区进行大量操作的情况
- 日期时间类
-
Date
Date date = new Date();//获取当前时间 -
SimpleDateFormat
(1)Date转String
SimpleDateFormat sdf = new SimpleDateFormat(“yyyy年MM月dd日 hh时mm分ss秒 SSS E D”);
String strDate = sdf.format(date);
System.out.println(strDate);
(2)String转Date
String str = “2018年10月01日 10:30:30”;
SimpleDateFormat sdf2 = new SimpleDateFormat(“yyyy年MM月dd日 hh:mm:ss”);
Date date2 = sdf2.parse(str);//异常
System.out.println(date2);获得系统时间的毫秒数
long start = System.currentTimeMillis( );
long end = date.getTime(); -
Calendar
//获取Calendar对象
Calendar c = Calendar.getInstance();
System.out.println©;//修改Calendar的时间 //c.set(2009, 6-1, 12); //获取日期的部分信息--年份 System.out.println(c.get(Calendar.YEAR)); System.out.println(c.get(Calendar.MONTH)); System.out.println(c.get(Calendar.DAY_OF_MONTH)); System.out.println(c.get(Calendar.DAY_OF_WEEK)); System.out.println(c.get(Calendar.HOUR)); System.out.println(c.get(Calendar.HOUR_OF_DAY)); //单独设置属性值 c.set(Calendar.YEAR, 2009); c.add(Calendar.YEAR, 5); c.add(Calendar.MONTH, 2); System.out.println(c.get(Calendar.YEAR));//2014 System.out.println(c.get(Calendar.MONTH));//5 //判断闰年 GregorianCalendar gc = new GregorianCalendar(); System.out.println(gc.isLeapYear(1900));
-
包装类
//包装类 (Byte,Short,Integer,Long Float,Double Character Boolean)
//基本数据类型(byte,short,int,long float,double char boolean)//面向对象编程 int num0 = 10;//数字 Integer num1 = new Integer(20);//对象 //Student student = new Student(); //封箱(基本数据类型--->包装类)比如:int-->Integer Integer num2 = new Integer(num0); Integer num3 = Integer.valueOf(num0); //拆箱(包装类--->基本数据类型)比如:Integer-->int int num4 = num1.intValue(); //自动封箱,拆箱 Integer num6 = 10; int num5 = new Integer(10); //数值字符串 转成 基本数据类型 例子: "10" --> 10 String str = "10"; System.out.println(str + 1); int num7 = Integer.parseInt(str); System.out.println(num7 + 1); String str2 = "2.5"; System.out.println(str2 + 1); float f = Float.parseFloat(str2); System.out.println(f + 1);
-
数学类
//数学类
System.out.println(Math.E);
System.out.println(Math.PI);System.out.println(Math.abs(-10.25));//绝对值 System.out.println(Math.sin(Math.PI/6)); System.out.println(Math.cos(Math.PI/3)); System.out.println(Math.ceil(2.5));//天花板 System.out.println(Math.floor(2.5));//地板 System.out.println(Math.round(2.26));//近似值 System.out.println(Math.sqrt(9));//开平方根 System.out.println(Math.cbrt(8));//开立方根 System.out.println(Math.pow(3, 4));// 求幂 System.out.println(Math.max(10, 8));//最大值 System.out.println(Math.min(10, 8));//最小值 System.out.println(Math.toDegrees(Math.PI/6));//弧度 转 角度 System.out.println(Math.toRadians(30));//角度 转 弧度 System.out.println(Math.random());//随机数 0<=x<1 System.out.println(Math.multiplyExact(2, 3));//乘法 System.out.println(Math.negateExact(10));//取反
-
System和Runtime
System.out.println(“Hello”);
System.err.println(“Hello”);
Scanner sc = new Scanner(System.in);
//系统环境变量
Map<String, String> map = System.getenv();
for (String string : map.keySet()) {
System.out.print(string+"标签:总结,Java,String,int,System,2019.10,println,public,out 来源: https://blog.csdn.net/HeiSeHuoEr/article/details/102474421