1.注释 //单行注释 /*多行注释*/ /**javaDoc:文档注释 /** * @Description hello */ /** * _ooOoo_ * o8888888o * 88" . "88 * (| -_- |) * O\ = /O * ____/`---'\____ * . ' \\| |// `. * / \\||| : |||// \ * / _||||| -:- |||||- \ * | | \\\ - /// | | * | \_| ''\---/'' | | * \ .-\__ `-` ___/-. / * ___`. .' /--.--\ `. . __ * ."" '< `.___\_<|>_/___.' >'"". * | | : `- \`.;`\ _ /`;.`/ - ` : | | * \ \ `-. \_ __\ /__ _/ .-` / / * ======`-.____`-.___\_____/___.-`____.-'====== * `=---=' * * 佛祖保佑 永无BUG * ............................................. */
2.标识符
3.数据类型
public class helloworld{
public static void main(String[] args) {
String a = "hello";
int mun = 10;
System.out.print(a);
System.out.print(mun);
}
}
public class helloworld{
public static void main(String[] args) {
//八大基础数据类型
//整数
int num1 = 10; //最常用
byte num2 = 20;
short num3 = 30;
long num4 = 30L; // Long类型要在数字后面加L
//小数：浮点数
float num5 = 50.1F;// float类型要在数字后面加F
double num6 = 3.141592654;
//字符
char name = 'A';
//字符串，String 不是关键字，是类 // String name = "xiaodi";
//布尔值：是非
boolean flag = true;
boolean flag1 = false;
}
}
public class helloworld{
public static void main(String[] args) {
//整数拓展： 进制 二进制0b 十进制 八进制0 十六进制0x
int i1 = 10;
int i2 = 010; //八进制0
int i3 = 0x10; //十六进制0x 0~9 A~F
System.out.println(i1);
System.out.println(i2);
System.out.println(i3);
}
}
public class helloworld {
public static void main(String[] args) {
//浮点数拓展
//银行业务数字，不用浮点的float和double表示，一般用：BigDecimal 数学工具类
//场景1
float f = 0.1f;
double d = 1.0/10;
//广义理解以上两个变量，算出来都是0.1,但是代码中，是不等于的
System.out.println(f==d); //输出结果为：false
System.out.println(f); //0.1
System.out.println(d);//0.1
//场景2
float d1 = 32323232323232f;
float d2 = d1+1;
System.out.println(d1==d2);//广义理解以上两个变量不一样，输出结果预期是false,实际运行结果为true
// 因为浮点数取数是有限的，结果只是接近，大约
}
}
public class helloworld {
public static void main(String[] args) {
//字符拓展
char c1 = 'a';
char c2 = '中';
System.out.println(c1); //实际输出结果 a
System.out.println(c2); //实际输出结果 中
System.out.println((int)c1);//强制转换可以把字符转换为数字： 实际输出结果 97
System.out.println((int)c2); //强制转换为数字后 实际输出结果 20013
//以上4个输出代表：所有的字符本质上还是数字，通过Unicode编码 来编码的。
//有对应的编码：类似以上：a=97 中=20013 输出时会去查Unicode编码的表
//Unicode编码的表示方式 U0000 UFFFF
char c3 = '\u0061'; //\u 转义
System.out.println(c3); //输出结果为：a
//C3的输出结果，充分说明了
//Unicode(统一码)其实相当于一本很厚的字典，里面储存了世界上所有语言的字符，使用Unicode码点唯一地对应一个字符。
//2,转义字符
// \t 制表符（空格）
// \n 换行
}
}
public class helloworld {
public static void main(String[] args) {
//布尔值扩展
boolean flag = true;
if (flag==true){} //新手写法
if (flag){} //老手写法，默认为真 //精简易读
}
}
4.类型转换
1、其中byte、short、int、long都是表示整数的，只不过他们的取值范围不一样
byte的取值范围为-128~127，占用1个字节（-2的7次方到2的7次方-1）
short的取值范围为-32768~32767，占用2个字节（-2的15次方到2的15次方-1）
int的取值范围为（-2147483648~2147483647），占用4个字节（-2的31次方到2的31次方-1）
long的取值范围为（-9223372036854774808~9223372036854774807），占用8个字节（-2的63次方到2的63次方-1）。
2、浮点：float、double
float在储存大型浮点数组的时候可节省内存空间；浮点数的默认类型为double类型；浮点数不能用来表示精确的值，
3、字符类型 char
char类型是一个单一的16位Unicode字符；（2字节）
最小值是’\u0000’（即为0）；
最大值是’\uffff’（即为65,535）； 2的16次方 -1 （2^16 -1）
public class helloworld {
public static void main(String[] args) {
//类型转换
/**
* 1,不能对布尔值进行转换
* 2,不能把对象类型转换为不相关的类型
* 3,在把高容量转换到低容量的时候需要强制转换，低转高不需要
* 4,转换的时候可能存在内存溢出，或者精度问题
*/
//强制转换 格式：（类型）+变量名
//自动转换 低-高
//场景一，转换时内存溢出
int i = 128;
byte b = (byte)i; //这里如果写成 byte b = i; 会报错，b是byte类型，但是i是int类型。所以强制转换的格式很重要。
System.out.println(i); //输出结果 128
System.out.println(b); //输出结果 -128
//造成以上输出结果的原因是，byte最大数是127,128时，就造成了内存溢出，所以输出结果会是负数
//场景二：数据高到低需要强制转换， 低到高，可以自动转换
int i2 = 128;
double b2 = i2;
System.out.println(i2); //输出结果 128
System.out.println(b2); //输出结果 128.0
//场景三，精度丢失问题。
System.out.println((int)23.7); //输出结果： 23 丢失了小数点后数据
System.out.println((int)-45.89F); //输出结果： -45 丢失了小数点后数据
//场景四,字符转数字
char c = 'a';
int d = c+1; //低转高，自动转换
System.out.println(c); //输出结果：a
System.out.println(d); //输出结果：98
System.out.println((char)d); //输出结果：b 说明在Unicode编码中，98 就是b 编码-1,97就是a
char c4 = '\u0098';
System.out.println(c4); //验证一下上面的结果，输出结果为b
}
}
public class helloworld {
public static void main(String[] args) {
//操作比较大的数的时候，注意溢出问题
//场景1：Jdk7新特性数字之间可以下划线_分割，不影响输出结果
int money = 10_0000_0000;
System.out.println(money); //输出结果，1000000000
//场景2：
int years = 20;
int total = money*years;
System.out.println(total); //实际输出结果：-1474836480，期待结果200_0000_0000 这样就内存溢出了
long total2 = money*years;
System.out.println(total2); //这样使用long,也不行，因为两个变量是int,就是默认int,在转换之前就已经内存溢出了
long total3 = money*((long)years);
System.out.println(total3); //实际输出结果，20000000000，这样写就不会存在内存溢出问题了。
//PS:int数据范围-2147483648-2147483647 最大21亿，以上变量计算结果为200亿，所以内存溢出；
}
}
5.变量
public class helloworld {
public static void main(String[] args) {
//变量
//int a,b,c
// int a=1,b=2,c=3;不建议这么写，要注意程序的可读性
int a=1;
int b=2;
int c=3; //尽量采用这种分行来写 int属于基本类型变量
String name = "xiaodi"; //String属于引用类型变量
char X = "xiao";
double pi = 3.14;
}
}
//变量作用域-局部变量
public class helloworld { //helloworld 就是类，类名
//类里面除了像main的方法，还能定义属性 属性可以理解为就是一个变量
public static void main(String[] args) { //main方法 默认的主程序方法
//局部变量：局部变量是在方法或者语句块里边的，
// 在两个{}之间的，有效期从第一个{开始，到}结束。
//而且必须声明和初始化值
//int i; //而且必须声明和初始化值
int i=10; // i这个变量只能在这一个方法里边使用，其他方法不能用。
System.out.println(i);
}
//类里面除了像main的方法，还能写其他方法，比如于下方add方法
public void add(){
}
}
//变量作用域-实例变量
public class helloworld {
//实例变量，不在方法里边，在类里边，从属于对象的，（从属于helloworld这个类）
String name; //实例变量可以不初始化，直接用
int age;
public static void main(String[] args) {
helloworld helloworld = new helloworld();
//变量类型 变量名 = 值（变量就是自己helloworld）
System.out.println(helloworld.name); //输出结果 null 因为上面没有初始化值，而在实例变量中，如未初始化值，就会变成这个类型的输出默认值
System.out.println(helloworld.age); //输出结果 0
// 整数 0 小数0.0 布尔值fales
// 除了基本类型，其他的都是null 包括String
}
}
//变量作用域-类变量-static
public class helloworld {
static double salary = 2500; //只要加了关键字static,就是从属于类的变量，可以直接使用
public static void main(String[] args) {
System.out.println(salary);
}
}
6.常量
//常量-final
public class helloworld {
static final double PI = 3.14; //static 和final 位置可以不区分前后 ，他俩都是修饰符，修饰符不存在先后顺序，public也是
//常量也属于类变量，所以需要加static
//项目中一些定死的值，就可以用常量，常量定义后，就不能变。静态常量
public static void main(String[] args) {
System.out.println(PI);
}
}
标签：01,java,int,数据类型,System,helloworld,println,public,out From： https://www.cnblogs.com/xiaodi888/p/18119279