Java基础-程序基础

Java基础

  • Java基础-java程序基础
    • java程序基本结构
    • 变量和数据类型
      • 什么是变量
      • java的基本数据类型
      • 常量
    • 整数运算
      • 运算规则
      • 移位运算
      • 位运算
      • 运算优先级
      • 类型自动提升与强制转型
    • 浮点数运算
      • 浮点数的特点
      • 强制转型
    • 布尔运算
      • 布尔运算的运算符
      • 短路运算符
      • 三元运算符
    • 字符和字符串
      • 字符类型
      • 字符串类型
      • 字符串操作
      • 理解引用类型
      • 总结
    • 数组类型
      • 什么是数组类型
      • 总结

Java基础-java程序基础

hello everyone,here is java world!

java程序基本结构

/**
 * 可以用来自动创建文档的注释
 */
public class Hello {
	public static void main(String[] args) {
		// 向屏幕输出文本
		System.out.println("Hello, world!");
		/*
 		* 可以用来自动创建文档的注释
 		*/
	}
} // class定义结束

java程序最基本的结构:

class 类名 {
}

java对格式没有明确要求,多几个空格或者换行都没有关系,但是会我们要养成良好的编程习惯,遵守java社区约定的编程格式

class 
	Hello 
	{
}

我们前面提到的Eclipse的快捷键:Ctrl+Shift+F可以帮助我们快速格式化代码,Eclipse就是按照约定的格式对代码进行格式化的,如果要知道java代码的具体格式要求,可以在Eclipse的设置中找到
Java基础-程序基础_第1张图片
因为java是面向对象语言,所以程序的基本单元就是class,class的命名规则需要注意:

类名必须是英文字母、数字、下划线的组合
类名必须以英文首字母开头
要注意遵守命名习惯,好的命名:Hello、NoteBook、VRPlayer
不好的命名:hello(首字母没大写)、Good123(123无实际意义)、Note_Book(带下划线)、_World(下划线开头)

public用来修饰当前类是公开的,不写public也可以正常编译,但是这样无法从命令行执行,在一个class的内部我们可以定义很多方法,方法的定义是由返回值、方法名称、参数构成,方法内部定义的是一组执行语句,方法内部的代码将会被JVM执行

public class 类名 {
	返回值 方法名 (参数) {
	
	}
}

Java基础-程序基础_第2张图片

java程序规定的入口程序必须是
`public static void main(String[] args) {
}

方法名也有好的命名和不好的命名,和class一样,但是首字母要小写:

好的命名:main、goodMorning、playVR
不好的命名:Main(首字母大写)、good123(123无实际意义)、good_morning(带下划线)、_playVR(下划线开头)

在方法的括号中间,语句是真正的执行代码,每一句必须以分号结尾

System.out.println(“Hello, world!”);

什么是注释:注释是给人阅读的、编译器会自动忽略注释,java的注释总共有三种:

单行注释:以 // 开头,到当前行尾
多行注释:用 /* … / 表示,以 / 开头,/ 结尾,中间的所有内容都被视为注释
特殊的多行注释:用 /** … / 表示,以 /* 开头,
/ 结尾,写在类和方法的定义处,可用于自动创建文档

变量和数据类型

什么是变量

类似于数学的方程式:y = x2 + 1,其中y和x都是变量
Java基础-程序基础_第3张图片
变量的一个重要特点:可以重新被赋值,我们可以看下面的执行过程
Java基础-程序基础_第4张图片
我们可以在Eclipse里用debug模式运行,一步步观察打印结果,当我们点击debug运行,Eclipse会提示我们切换到debug模式,我们点击Yes,并勾选Remember my decision(记住我的决定),这样下次就不会再提示了
Java基础-程序基础_第5张图片
Java基础-程序基础_第6张图片

java的基本数据类型

整数类型:long、int、short、byte
浮点类型:double、float
布尔类型:boolean
字符类型:char

计算机内存最小的存储单元是位(bit),基本计量单位是字节,一个字节是8位,二进制数:00000000 ~ 11111111(0 ~ 255),内存单元从0开始编号,称为内存地址,一个存储单元相当于一个字节
Java基础-程序基础_第7张图片
java类型对应计算机中的字节个数:
在这里插入图片描述

byte:8位,1个字节,范围-128~127(-27 ~ 27 - 1)
short:16位,2个字节,范围-32768~32767(-215 ~ 215 - 1)
int:32位,4个字节,范围(-231 ~ 231 - 1)
long:64位,8个字节,范围(-263 ~ 263 - 1),long形整数定义时需要在数字末尾加上 L (小写 l 不推荐使用,容易和数字1混淆),例如:long x = 10L;不加 L 编译默认定义为int类型
float:32位,4个字节,需要在结尾加上 f ,一个浮点类型可以用科学计数法来表示:float f = 3.14e38f(3.14 * 10 38
double:64位,8个字节
boolean:1位,1/8个字节,只有两个值,true和false,通常用来比较计算结果,例如:boolean x = 5 >3;
char:16位,2个字节,只能表示一个字符,用单引号表示,例如:char x = ‘中’;
同一个数的不同进制表现是完全不同的:15 = 0xf(16进制) = 0b1111(二进制),为什么将小数称为浮点数,是因为它的小数点是可以浮动的,例如这两个数是相等的:12.34e5 = 1.234e6,我们要区分字符和字符串类型,字符类型用单引号表示,并且只能有一个字符

public class IntType {

	public static void main(String[] args) {
		byte b = 127; // -128 ~ +127
		short s = 32767; // -32768 ~ +32767
		int i = 2147483647; // -2147483648 ~ +2147483647
		long l = 9_000_000_000_000_000_000L; // -9223372036854775808 ~
										// +9223372036854775807
		System.out.println(b);
		System.out.println(s);
		System.out.println(i);
		System.out.println(l);

		int i3 = 2_000_000_000;
		int i4 = 0xff0000; // 十六进制表示的十进制16711680
		int i5 = 0b1000000000; // 二进制表示的十进制512
		System.out.println(i3);
		System.out.println(i4);
		System.out.println(i5);
		// 输出十六进制表示的整型:
		System.out.println(Integer.toHexString(12345678)); // bc614e
		// 输出二进制表示的整型:
		System.out.println(Integer.toBinaryString(12345678)); // 101111000110000101001110
	}

}

常量

常量就是用final修饰的变量
常量初始化后不可再次赋值
常量名通常全部大写
常量用来避免意外赋值
常量用来代替Magic Number(魔幻数字,硬编码值,一段时间之后容易忘记代表的含义)

public class Constant {

	public static void main(String[] args) {
		final double PI = 3.14;
//		PI = 3.1415;  // 编译报错
		double r = 4.0;
		double length = PI * r * 2;
		double area = PI * r * r;
		System.out.println(length);
		System.out.println(area);
		// magic number:
		double salary = 12500.0;
		double pay = salary * (1 - 0.2);
//		final double TAX_RATE = 0.2;
//		double pay = salary * (1 - TAX_RATE);
		System.out.println(pay);
	}

}

整数运算

运算规则

基于四则运算规则
除法结果为整数
除数为0,运行时会报错,但编译不会报错
java提供了++运算和–运算符,++n或者n++代表n = n + 1,–n或者n–代表n = n - 1,运算符在数字前代表先+1再引用,运算符在数字后代表先引用再+1
java提供了+=和-=运算符,n += 100相当于n = n + 100,n -= 100相当于n = n - 100

public class Div {

	public static void main(String[] args) {
		int i = 99 / 9;
		System.out.println(i);
		// 整数运算的结果仍然是整数:
		int n = 100 / 9;
		System.out.println(n);
		int z = 100 / 0; // 报错,错误信息会告诉我们错误类型以及具体在哪一行,后面的语句不会执行
		System.out.println(z);
	}
}

整数运算需要注意

计算结果溢出不报错,但是计算结果不正确,例如:int x = 2147483647 + 1;计算结果为-2147483648
解决方案:用范围更大的整形进行运算,long x = 2147483647L + 1

移位运算

左移:<<
带符号右移:>>
不带符号右移:>>>
byte和short会先转换为int再进行移位

int n1 = 5;

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1

int n2 = n1 << 10; // 5120

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0

int n3 = n2 >> 11; // 2,最右边的1超出了范围,所以被丢弃

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0

int n4 = n1 << 29; // -1610612736,最高位表示的是符号位,所以表示的是一个负数

1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

int n5 = n4 >> 29; // -3,符号位会被保留

1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1

int n5 = n4 >>> 29; // 5,符号位不会被保留

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1

位运算

与运算:&,位上的值都是1才是1,否则为0,1 & 1 = 1; 1 & 0 = 0; 0 & 1 = 0; 0 & 0 = 0;
或运算:|,位上的值有一个1就是1,否则为0,1 | 1 = 1; 1 | 0 = 1; 0 | 1 = 1; 0 | 0 = 0;
异或运算:^,位上的值不相同则为1,相同为0,1 ^ 0 = 1; 0 ^ 1 = 1; 1 ^ 1 = 0; 0 ^ 0 = 0;
非运算: 1 = 0,~ 0 = 1;

int n1 = 0x03_83_d0_25;

0 0 0 0 0 0 1 1 1 0 0 0 0 0 1 1 1 1 0 1 0 0 0 0 0 0 1 0 0 1 0 1

int n2 = 0x00_00_ff_ff;

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

int n3 = n1 & n2; // 53285, 0x00_00_d0_25

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 1 0 0 1 0 1

int n4 = n1 | n2; // 0x03_83_ff_ff

0 0 0 0 0 0 1 1 1 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

运算优先级

由高到低:

1.~ ++ --
2.* / %
3.+ -
4.<< >>
5.&
6.|

一般我们很难记住这些运算符的优先级,所以可以使用括号()来明确执行顺序

类型自动提升与强制转型

在运算过程中,计算结果为较大类型的整形
short s = 12; int i = 100 + s; long n = 999 * i;
可以将结果强制转型,(类型)变量或数值
int y1 = (int) (n - 199); int y2 = (int) n - 199;
强制转型可能会丢失精度,当超过最大位数,会将高位全部抛弃
int z = (int) (n * 100000000)

我们要选择合适的类型进行运算,没有必要为了节省内存使用byte或short,因为它们表示的范围太小

浮点数运算

浮点数的特点

很多浮点数无法精确表示,例如:double a = 0.1;二进制表示:0.0 0011 0011 0011…,这是一个无限小数,计算机不可能在有限的内存中表示一个无限的小数
计算有误差:double b = 1 - 9/10; 理论上结果应该是0.1,但是因为浮点数无法精确表示,所以在计算过程中会有误差
整形可以自动提升到浮点形:double d1 = 1.2 + 24.0/5; 结果是6.0
特别注意,类型不能自动提升的情况:double d1 = 1.2 + 24/5; 结果是5.2

public class FloatOps {

	public static void main(String[] args) {
		double a = 0.1;
		double b = 1 - 9.0 / 10;
		System.out.println(a); // 0.1
		System.out.println(b); // 0.09999999999999998
		// 注意没有自动提升的情况:
		double d1 = 1.2 + 24.0 / 5; // 6.0
		double d2 = 1.2 + 24 / 5; // 5.2
		System.out.println(d1);
		System.out.println(d2);
	}
}

浮点数计算有几个特殊值需要注意:

NaN:Not a Number
Infinity:无穷大
-Infinity:负无穷大

public class NaN {

	public static void main(String[] args) {
		double d1 = 0.0 / 0; // NaN
		double d2 = 1.0 / 0; // Infinity
		double d3 = -1.0 / 0; // -Infinity
		System.out.println(d1);
		System.out.println(d2);
		System.out.println(d3);
	}
}

强制转型

强制转为整形会直接扔掉小数位
四舍五入的技巧
超出整形范围会自动变为最大值

public class ToInt {

	public static void main(String[] args) {
		int n1 = (int) 12.3; // 12
		int n2 = (int) 12.7; // 12
		int n3 = (int) (12.7 + 0.5); // 13
		int n4 = (int) 1.2e20; // 2147483647
		System.out.println(n1);
		System.out.println(n2);
		System.out.println(n3);
		System.out.println(n4);
	}
}

布尔运算

布尔运算的运算符

关系运算:< ,<=,>,>=,==,!=
与运算:&&
或运算:||
非运算:!

短路运算符

与运算:&&,参与运算的操作数只要有一个是false那么就是false,所以确定为false后,后面的运算操作将不再进行运算,例如:boolean and = false && (5 / 0 > 0); // false
或运算:||,参与运算的操作数只要有一个是false那么就是true,所以确定为true后,后面的运算操作将不再进行运算,例如:boolean or = true || (5 / 0 > 0); // true
因为短路运算符的规则,(5 / 0 > 0)将不会运行,否则程序将会报错

三元运算符

根据条件b计算x或y:b ? x : y
x和y只计算其中一个
x和y类型必须相同

字符和字符串

字符类型

字符类型是基本数据类型,一个char类型保存一个字符,他可以保存一个英文字符,也可以保存一个中文字符

java使用Unicode编码来表示字符,我们要看一个char类型的Unicode编码,可以直接将一个char类型赋值给int类型,这个int类型的值就是Unicode编码,例如:
int x = 'A'; // 65
int y = '中'; // 20013
我们也可以直接用Unicode编码来表示,方法是用\u + 4位16进制数表示:
char x = '\u0041'; // 'A'
char y = '\u4e2d'; // '中'

字符串类型

字符串类型不是一个基本类型,它是引用类型
字符串类型String,表示一个字符串,字符串内容用双引号表示,字符串内容并不包含开头结尾的两个双引号
转移字符:
如果我们需要表示一些特殊字符,我们就需要用到转移字符,常用的转移字符:\n,",\r,\t,\

字符串操作

字符串最常用的操作是字符串连接,用+连接,我们可以连接两个字符串也可以将字符串和其他类型进行连接,例如:
String x = "hello" + ",world!"; String y = "age is " + 12;

理解引用类型

字符串是引用类型,字符串是不可变的
引用类型特点:变量指向某个对象,而不是持有某个对象
所有的应用类型都可以指向一个特殊的值:null(空值),当我们给一个引用变量赋值为null,我们可以认为当前变量不指向任何对象,但是空值null和空字符串是不一样的,空字符串也是一个对象,例如:
String s = null;
System.out.println(s); // null
String t = "";
System.out.println(t);

Java基础-程序基础_第8张图片
Java基础-程序基础_第9张图片

总结

区分字符类型(基本类型)和字符串类型(引用类型)
基本类型的变量是持有某个数值
引用类型的变量是指向某个对象
引用类型的变量可以是null
区分空(null)和空字符串("")

数组类型

什么是数组类型

当有一组类型相同的变量时,可以用数组表示

数组类型是"类型[]",数组初始化用 new 类型[长度],例如:int[] ns = new int[5]; 也可以直接指定初始化元素,由编译器自动为我们推算出数组的大小,例如:int[] ns = new int[] {68, 79, 91, 85, 61}; 还可以进一步简写,例如:int[] ns = {68, 79, 91, 85, 61};
数组初始化所有元素为默认值,对于int数组默认值全部都是0
数组创建后大小不可变,即数组长度不可变,但数组变量是可以指向另一个数组对象
数组索引从0开始
可以用 数组变量.length 获取数组长度
数组是一种引用类型的变量
使用索引(下标)访问数组元素,索引超出范围将报错

public class Hello {
	public static void main(String[] args) {
		// 5位同学的成绩
		int n1 = 68;
		int n2 = 79;
		int n3 = 91;
		int n4 = 85;
		int n5 = 61;
		
		int[] ns = new int[5];
		ns[0] = 68;
		ns[1] = 79;
		ns[2] = 91;
		ns[3] = 85;
		ns[4] = 61;
		
		System.out.println(ns.length); // 5
		System.out.println(ns[2]); // 91
		System.out.println(ns[5]); // Error!
		
		ns = new int[] {1, 2, 3}; // 这是可行的,数组本身没有变,只是ns变量从一个数组对象指向另一个数组对象,数组本身是没有变的,它只是创建了一个新的数组对象

		String[] names = {"xiaoming", "xiaohong", "xiaojun"}; // 字符串数组的每一个元素都指向一个字符串对象
		names[2] = "daniu"; // 将原来数组2号位的指向从xiaojun指向了新的字符串daniu
	}
}

Java基础-程序基础_第10张图片
Java基础-程序基础_第11张图片

public class Main {
	public static void main(String[] args) {
		int[] ns1 = new int[5]; // { 0, 0, 0, 0, 0 }
		int[] ns2 = new int[] { 1, 3, 5, 7, 9 };
		int[] ns3 = { 2, 4, 6, 8, 10 };
		int[] ns4 = ns3;
		System.out.println("ns1.length: " + ns1.length);
		System.out.println("ns2.length: " + ns2.length);
		System.out.println("ns3.length: " + ns3.length);
		// 现在ns3和ns4指向同一个数组:
		System.out.println("ns3[1]: " + ns3[1]);
		ns3[1] = 999;
		System.out.println("ns4[1]: " + ns4[1]);
		// 把ns3指向一个新数组:
		ns3 = new int[] { 1, 2, 3 };
		ns3[1] = 888;
		System.out.println("ns4[1]: " + ns4[1]);
		// String数组:
		String[] strs = { "Abc", "Xyz", "123" };
		strs[1] = "Hello";
	}
}
打印结果:
ns1.length: 5
ns2.length: 5
ns3.length: 5
ns3[1]: 4
ns4[1]: 999
ns4[1]: 999

总结

数组是同一数据类型的集合
数组是引用类型
数组元素是值类型(如int[])或引用类型(如String[])
数组一旦创建大小不可变
可以通过索引访问数组元素
索引超出范围将报错

你可能感兴趣的:(Java基础,java,后端)