Java从零开始（Day02 Day03）

已于 2022-07-08 18:58:21 修改
阅读量193 收藏
点赞数
分类专栏： java 文章标签： java jvm 开发语言
于 2022-07-06 19:53:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55965645/article/details/125645079
版权

目录

二、Java语言基础

1.关键字与保留字

2.标识符

3.变量概念引入

4.变量的定义方式

5.单位换算

6.数据类型

6.1整形

6.2 浮点类型

6.3布尔类型

6.4字符类型

7.转义字符

8.String类型

二、Java语言基础

1.关键字与保留字

        被java官方赋予了特殊含义的全部小写的单词，注意取名字不要与关键字或者保留字冲突。

2.标识符

        凡事需要自己定义名称的内容都叫标识符

        类名首字母大写，不推荐使用中文、拼音、特殊符号，见名知意，有意义。

3.变量概念引入

        生活中我们通常需要记录数据，记录方式多种多样，程序中我们也同样需要记录数据， 程序中通过变量来记录数据。变量就是用来记录数据的。

        举例：比如你的同桌需要大宝剑，发现钱不够，找你借五毛钱。

        人物：你的同桌

        事件：借钱大宝剑

        金额：0.5元 5毛

        时间：2022年7月6日18:06:34

        ......

        通过以上记录数据分析，我们发现这些数据是有不同的数据类型的，java中的数据也是由不同的数据类型来存储的。变量有不同的数据类型。

4.变量的定义方式

        声明变量的三种方式：

        先声明，再赋值：【常用】

        数据类型 变量名；

        变量名 = 值；

        声明并赋值：【常用】

        数据类型 变量名= 值；

        多个同类型的变量的声明与赋值：【了解】

        数据类型 变量1，变量2，变量3=值3，变量4，变量5=值5；

Public class Test1{
    public static void main(String[] args){
        //变量定义的三种方式
        //方式一 先声明 再赋值
        int a;
        a = 5;
        System.out.println("变量a的取值是："+ a);
        
        //方式2 连声明带赋值 写为一条语句
        int b = 22;
        System.out.println("变量b的取值是："+b);
        
        //方式3 同时声明多个‘同类型’的变量 赋值‘个别’变量
        int c,d,e = 55,f = 66;
        
        System.out.println("变量e取值是：" + e);
        System.out.println("变量f取值是：" + f);
        
        //未赋值的（局部变量）变量不能使用
        System,out.println("变量c取值是:" + c);
        System.out.println("变量d取值是:" + d );
    }
}

5.单位换算

        1TB = 1024GB

        1GB = 1024MB

        1MB = 1024KB

        1KB = 1024Byte（字节）

        1Byte = 8bit（位）

6.数据类型

6.1整形

long取值范围如需为long类型赋值 如果取值范围超过int，必须在末尾追加L，大小写都可以，推荐大写，如果没超过int，可以不追加。

public class Test1{
	public static void main(String [] args){
		// 整数类型 byte short int long
		
		// byte 取值范围 -128 ~ 127
		byte b1 = 20;
		System.out.println(b1);
		
		// byte b2 = 128;
		// System.out.println(b2);
		
		
		// byte b3 = -129;
		// System.out.println(b3);
		
		System.out.println("-------------------------------------");
		
		// short 取值范围  -32768 ~ 32767
		short s1 = 2356;
		short s2 = 3366;
		// short s3 = 32768;
		System.out.println(s1);
		System.out.println(s2);
		// System.out.println(s3);
		
		System.out.println("-------------------------------------");
		
		// int 取值范围  -2147483648 ~ 2147483647 
		int i1 = 20;
		int i2 = 30;
		// int i3 = 2147483648;
		System.out.println(i1);
		System.out.println(i2);
		// System.out.println(i3);
		
		System.out.println("-------------------------------------");
		
		// long 取值范围 如需为long类型赋值 如果取值范围超过int
		// 必须在值的末尾追加L  大小写都可以 推荐大写 
		// 如果没有超过int  可加可不加
		
		long l1 = 2356L;
		System.out.println(l1);
		
		long l2 = 895678l;
		System.out.println(l2);
		
		long l3 = 2147483648L;
		System.out.println(l3);
	}
}

6.2 浮点类型

     double为浮点数的默认类型，如需为float类型赋值，需要在值的后面追加"F"

public class Test1{
	public static void main(String [] args){
		// 浮点类型
		// float 负数 -3.4E+38 ~ -1.4E-45
		
		float f1 = -340000000000000000000000000000000000000F;
		
		float f2 = -0.0000000000000000000000000000000000000000000045F;
		
		System.out.println(f1);
		
		System.out.println(f2);
		
		
		// float 正数  1.4E-45 ~ 3.4E+38
		
		float f3 = 0.0000000000000000000000000000000000000000000014F;
		
		float f4 = 340000000000000000000000000000000000000F;
		
		System.out.println(f3);
		System.out.println(f4);
		
		// 小数的默认类型为double类型 
		double d1 = 2.5;
		double d2 = 95.2;
		
		System.out.println(d1);
		System.out.println(d2);
		
		
	}
}

6.3布尔类型

可直接赋值true/false

也可以赋值一个结果为true/false的表达式

注意：Java中的boolean不能参与算数运算 

6.4字符类型

字符赋值：char c1 = 'A'; (通过‘’描述为字符赋值)

整数赋值：char c2 = 65；（通过十进制数65在字符集中对应的字符赋值）

直接赋值整数数值，如果在0~127之间将参考ASCII码表

如果超出这个范围将参考Unicode编码表

进制赋值：char c3 = ‘\u0041’；（通过十六进制数41在字符集中所对应的字符赋值）

public class Test1{
    public static void main(String[] args){
        //char类型 取值范围
        
        //方式1 直接使用英文单引号包括 任意一个内容
        char ch1 = 'a';
        char ch2 = '中';
        char ch3 = '1';
        
        System.out.println(ch1);
        System.out.println(ch2);
        System.out.println(ch3);
    
        //char ch4 = '12';
        //System.out.println(ch4);

        //方式2 直接赋值取值范围在0~65535以内的整数
        char ch5 = 65;
        System.out.println(ch5);
		
		char ch6 = 66;
		System.out.println(ch6);
		
		char ch7 = 67;
		System.out.println(ch7);
		
		
		char ch8 = 20013;
		System.out.println(ch8);
		
		// Unicode编码表  万国码  记录了世界上大多数国家的语言  
		// Unicode是一个十六进制的字符集  
		// 中文取值范围是  \u4e00 ~ \u9fa5
		
		char ch9 = 20320;
		System.out.println(ch9);
		
		// 方式3  直接使用单引号包括 unicode字符序列    
		char ch10 = '\u597d';
		System.out.println(ch10);
		
		
		
		
	}
}
    }
}

7.转义字符

 java采用了转义字符来表示单引号和一些特殊符号

public class Test1{
	public static void main(String [] args){
		// 转义字符
		// \n 换行
		System.out.print("hello\n w\norld\n");
		System.out.print("世界\n你好\n");
		
		
		// \t 制表位/符   可以保证大多数情况下 上下行文字对齐
		System.out.println("床\t前\t明\t月\t光");
		System.out.println("疑\t是\t地\t上\t霜");
		
		
		char ch1 = '\\';
		System.out.println(ch1);
		
		char ch2 = '\'';
		System.out.println(ch2);
		
		
		char ch3 = '\"';
		System.out.println(ch3);
		
		
	}
}

8.String类型

public class Test1{
	public static void main(String [] args){
		// String类型  任何英文双引号包括的内容都叫字符串 
		String str1 = "abcdefg";
		String str2 = "124578";
		String str3 = "中国";
		String str4 = "A      B     C      D      E   ";
		
		System.out.println(str1);
		System.out.println(str2);
		System.out.println(str3);
		System.out.println(str4);
	}
}

9.类型转换

自动提升，手动下降

9.1自动类型转换

自动类型转换

1.两种类型要兼容，数值与数值类型兼容，char也可以存储数值

2.目标类型（等号左边）取值范围大于源类型（等号右边）

进行算术运算时：

两个操作数有一个为double，计算结果提升为double

如果操作数中没有double，有一个为float，计算结果提升为float

如果操作数中没有float，有一个为long，计算结果提升为long

如果操作数中没有long，有一个为int，计算结果提升为int

如果操作数中没有int，均为short或者byte或者char，计算结果提升为int

特殊：任何类型与String相加（+）时，时为拼接，其结果为String。

public class Test1{
	public static void main(String [] args){
		// 自动类型转换
		// 1.两种类型要兼容  数值与数值类型兼容 char类型也可以存储数值
		// 2.目标类型(等号左边)取值范围大于源类型(等号右边)
		
		byte b1 = 20;
		
		short s1 = b1;
		
		System.out.println(s1);
		
		
		short s2 = 2356;
		
		int i1 = s2;
		
		System.out.println(i1);
		
		
		int i2 = 568978;
		
		long l1 = i2;
		
		System.out.println(l1);
		
		
		long l2 = 5678;
		
		float f1 = l2;
		
		System.out.println(f1);
		
		
		float f2 = 3.4F;
		
		double d1 = f2;
		
		System.out.println(d1);
		
		System.out.println("----------------------------------");

	}
}
public class Test2{
	public static void main(String [] args){
		// 自动类型转换其他情况
		// byte、short、char类型 进行运算 结果提升int类型
		
		byte b2 = 23;
		
		short s2 = 56;
		
		int i3 = b2 + s2;
		
		System.out.println(i3);
		
		char ch1 = '中'; // 20013
		
		short s3 = 10;
		
		int i4 = ch1 + s3;
		
		System.out.println(i4);
		
		
	}
}

9.2强制类型转换

强制类型转换

1.两种类型要兼容

2.目标类型（等号左边）取值范围小于源类型（等号右边）

整数长度足够，数据完整

整数长度不够，数据截断。（符号位变化，可能变为负数）

public class Test1{
	public static void main(String [] args){
		// 强制类型转换
		// 1.两种类型要兼容
		// 2.目标类型(等号左边)取值范围小于源类型(等号右边)
		
		short s1 = 120;
		
		byte b1 = (byte)s1;
		
		System.out.println(b1);
		
		
		int i1 = 5689;
		
		short s2 = (short)i1;
		
		System.out.println(s2);
		
		
		long l1 = 567845;
		
		int i2 = (int)l1;
		
		System.out.println(i2);
		
		
		float f1 = 3.14F;
		
		long l2 = (long)f1;
		
		System.out.println(l2);
		
		
		double d1 = 20.5;
		
		float f2 = (float)d1;
		
		System.out.println(f2);
		
		System.out.println("==================================");
		
		
		int a = 23;
		
		byte b = (byte)a;
		
		System.out.println(b);
		
	}
}
public class Test2{
	public static void main(String [] args){
		// 强制类型转换特殊情况
		
		
		short s1 = 257;
		
		byte b1 = (byte)s1;
		
		System.out.println(b1);
		
		
		short s3 = 128;
		
		byte b2 = (byte)s3;
		
		System.out.println(b2);
		
		
		short s4 = 129;
		
		byte b3 = (byte)s4;
		
		System.out.println(b3);
		
		
		char ch1 = 'A';
		
		System.out.println(ch1 + 1); // 66 B  
		
		
		System.out.println(ch1 -1);
		
	}
}

10.运算符

10.1算数运算符

++或者--如果单独作为一条语句书写在前在后没区别

++或者--如果不是单独一条语句

如果++或者--在前 先执行++或者-- 再执行其他的

如果++或者--在后 先执行其他的再执行++或者--

public class Test1{
	public static void main(String [] args){
		// 算数运算符
		int a = 10;
		int b = 20;
		int c = 3;
		
		System.out.println(a + b);
		System.out.println(a - b);
		System.out.println(a * b);
		System.out.println(a / b); // 不能保存小数
		System.out.println(a % c);

	}
}

 

public class Test2{
	public static void main(String [] args){
		// ++ 表示自增1   
		// -- 表示自减1
		int a = 10;
		
		a++; // a = a + 1;
		
		System.out.println(a);
		
		
		int b = 15;
		
		b--; // b = b - 1;
		
		System.out.println(b);
		
		
		int c = 10;
		
		++c;  
		
		System.out.println(c);
		
		
		int d = 15;
		
		--d;
		
		System.out.println(d);
		
		System.out.println("------------------------------------");
		
		// ++或者-- 如果单独作为一条语句书写 在前在后没有区别
		// ++或者-- 如果不是单独一条语句
		// 如果++或者--在前 先执行++或者--  再执行其他的
		// 如果++或者--在后 先执行其他的 再执行++或者--
		
		
		int e = 10;
		
		int f = e++;
		
		System.out.println(f);
		
		System.out.println(e);
		
		
		
		System.out.println("------------------------------------");
		
		int h = 15;
		
		int j = h--;
		
		System.out.println(j); 
		
		System.out.println(h);
		
		System.out.println("------------------------------------");
		
		int k = 10;
		
		int m = ++k;
		
		System.out.println(m);
		
		System.out.println(k);
		
	}
}

 10.2赋值运算符

 

public class Test1{
	public static void main(String [] args){
		// 赋值运算符
		int a = 10; // 将等号右边赋值给等号左边  
		
		a += 10; // a = a + 10;
		
		System.out.println(a);
		
		a -= 5; // a = a - 5;
		
		System.out.println(a);
		
		
		a *= 6; // a = a * 6;
		
		System.out.println(a);
		
		
		a /= 3; // a = a / 3;
		
		System.out.println(a);
		
		
		a %= 2; // a = a % 2;
		
		System.out.println(a);
		
		System.out.println("-------------------------------");
		
		short s1 = 10;
		
		s1 += 10;
		
		int s2 = s1 + 10;
		
		
		byte b1 = 10;
		
		b1 += 10;
		
		int i2 = b1 + 20;

	}
}

11.3关系运算符

关系运算符最终结果都为布尔类型

public class Test2{
	public static void main(String [] args){
		// 关系运算符  最终结果都为布尔类型
		int a = 10;
		int b = 20;
		
		System.out.println(a > b);
		System.out.println(a < b);
		System.out.println(a >= b);
		System.out.println(a <= b);
		System.out.println(a == b);
		System.out.println(a != b);
	}
}

 10.4逻辑运算符

// 逻辑运算符 && 短路与 要求两个或多个表达式都成立 则结果为真 短路与 有短路的效果 如果第一个条件不成立 则后续的条件不再执行

& 逻辑与 要求两个或多个表达式都成立 则结果为真 没有短路效果

|| 短路或 要求两个或者多个表达式有一个成立 则结果为真 短路或 有短路的效果 如果第一个条件已经成立 则后续的条件不再执行

| 逻辑或 要求两个或者多个表达式有一个成立 则结果为真 没有短路效果

public class Test1{
	public static void main(String [] args){
		// 逻辑运算符
		// && 短路与 要求两个或多个表达式都成立 则结果为真
		// 短路与 有短路的效果 如果第一个条件不成立 则后续的条件不再执行
		
		// & 逻辑与 要求两个或多个表达式都成立 则结果为真  没有短路效果  
		
		
		// || 短路或 要求两个或者多个表达式有一个成立 则结果为真
		// 短路或 有短路的效果 如果第一个条件已经成立  则后续的条件不再执行
		
		
		// | 逻辑或 要求两个或者多个表达式有一个成立 则结果为真  没有短路效果
		
		int a = 10;
		int b = 20;
		int c = 15;
		
		System.out.println(a < b && b > c); // true
		
		System.out.println(a < b && b < c); // false
		
		System.out.println("=============================================");
		
		System.out.println(a < b & b > c); // true
		
		System.out.println(a < b & b < c); // false
		
		System.out.println("=============================================");
		
		int d = 56;
		int f = 66;
		int e = 88;
		
		System.out.println(d > f || f < e); // true
		
		System.out.println(d < f || f > e); // true
		
		System.out.println(d < f || f < e); // true
		
		System.out.println(d > f || f > e); // false
		System.out.println("=============================================");
		
		System.out.println(d > f | f < e); // true
		
		System.out.println(d < f | f > e); // true
		
		System.out.println(d < f | f < e); // true
		
		System.out.println(d > f | f > e); // false
		
		
		
	}
}

 

public class Test2{
	public static void main(String [] args){
		int x=8;
		int y=9;
		System.out.println((++x==y)&&(++x!=y)); // true
		System.out.println(x); // 10
		
		
		
		int a=8;
		int b=9;
		System.out.println((++a==b)||(++a!=b)); // true
		System.out.println(a); // 9
		
		
		int c=8;
		int d=9;
		System.out.println((c++==d)|(++c!=d)); // true
		System.out.println(c); // 10
		
		
		
		int e=8;
		int f=9;
		System.out.println((e++==f)&&(++e!=f)); // false
		System.out.println(e); // 9
		
		
		int j=8;
		int k=9;
		System.out.println((j++==k)&(++j!=k)); // false
		System.out.println(j); // 10
		
		
		



	}
}
public class Test3{
	public static void main(String [] args){
        // ! 取反
		boolean bl1 = !true;
		
		boolean bl2 = !false;
		
		System.out.println(bl1);
		
		System.out.println(bl2);
		
		System.out.println(!true);
		
		System.out.println(!false);
	}
}
public class Test4{
	public static void main(String [] args){
		// 三目(三元)运算符   布尔表达式 ?  结果1 : 结果2 
		
		System.out.println(20 == 20 ? "条件成立" : "条件不成立");
		
		int age = 19;
		
		System.out.println(age >= 18 ? "成年了" : "未成年");
		
		
		int a = 20;
		
		int b = a >= 20 ? 55 : 66;
		
		System.out.println(b);
		
		
	}
}

11.变量的命名规范

字下美人数骆驼

字：字母

下：下划线

美：美元符号$

人：人民币符号￥

数：数字

骆驼：驼峰命名 studentNameAndAge

可以以字母、下划线、美元符号、人民币符号开头，可以包含数字，不能以数字开头，见名知义，有意义

少喝点酒多吃菜
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值