Java Day03 笔记整理

1.Day01

1.JAVA开发语言

JAVA历史
   JAVA之父 詹姆斯 高斯林 
   95年
   96年明确发展方向--Java WEB
   09年 Oracle公司收购了Sun公司
   
版本众多 
    主流1.6 1.7 1.8 推荐使用1.8.241 

2.计算机

Java开发中运行的所有程序,需要考虑的内容
	cpu:cpu的使用率
	内存:内存的占用率
	硬盘:存储数据
	宽带:网络承载量
     涉及到服务器操作,需要考虑的带宽问题主要是上行带宽

3.操作系统

Winndows Linux UNIX macos Windows Server 塞班 IOS 
Android(不算是一个真正的操作系统)
   电脑的操作系统装64位的

4.操作方式

图形化操作界面:方便 简单 承载的内容多
命令行操作: 操作核心更加贴近核心业务 windows Dos命令 Linux            操作指令(重点)

5.DOS命令

dir    查看当年工作目录下的所有文件和文件夹
       .当前工作目录
        ..当前工作目录的上级目录
        
cd     切换工作目录   cmd>cd 路径
       相对路径:针对当前工作目录中的去向其他目录的一个最短路径
       绝对路径:有明确地址     根磁盘路径
       
makdir 创建文件夹

rd     删除文件夹 文件夹中存在内无法使用命令删除 不是放入回收站,而是自己抹掉数据

echo   cmd>echo 123>1.txt 必须有明确的文件名已经后缀名了解即可
       
del    区别于rd命令删除文件夹,del删除普通文件此命令必须需要有完整的名字+后缀名 同rd命令一样不是放入回收
       站,而是直接抹掉数据

*      通配符【慎用】

↑↓     回顾之前的操作命令

cls    清空

exit   退出

6.JDK安装

JDK官网
   https://www.oracle.com/java/technologies/javase-downloads.html 推荐1.8.241开发软件不允许安装到中文路径下

配置环境
   新建   JAVA_HOME 
   变量值  自己的JDK安装路径
   
   新建   CLASS_PATH
   变量值  .;%JAVA_HOME%\lib;%JAVA_HOME%\lib\tools.jar  注意.前不要有空格
   
   编辑   变量名:Path    ;%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;
   
   验证 javac     java      java—version

2.Day02 第一行代码

2.1FirstJava

class FirstJava {
	public static void main(String[] args) {
		System.out.println("你好");
	}
}

2.2编译执行

javac 编译 生成.class字节码文件 让后.class字节码交给java虚拟机运行
【重点 格式】 
        javac FirstJava.java ---javac xxxx.java
        编译生成字节码文件 
        java FirstJava   执行java代码对应的.class字节码文件

3.常见问题

1.class之后的名字要与文件名保持一致,且一定要保存成.java文件
2.注意大小写,和单词错误
3.标点符号错误 
      中英文符号
      为防止标点符号漏写成双成对的标点要一次写完                   ()【】{}“”‘’<>       

4.计算机存储单位

计算机中最小的存储单位是【字节】byte 
   一个字节对应8个byte位,8个二进制位 01011010
   八进制0开头 十六进制0X开头 X大小写都可

5.常量【伪重点】

代码运行的过程中不会发生改变的数据就是常量

开发中使用的常量
    整数  1 2 3 4
         -1 -2 -3 -4
    小数(浮点类型)
         3.14 0.0  0.01
    布尔类型(boolean)
          true 真/对  false 假/错
    字符常量
        【重点】 
            使用【英文单引号】包含的【单个元素】
            '你' 'A' '1' 'a'  
            '123'  错误的 啥也不是
    字符串常量
    	 【重点】
    	    使用【英文双引号】包含的所有内容
    	    "你好" "123" "1" 
5.1.代码演示常量使用
class Demo1 {
    public static void main(string[] args) {
        /*整数常量*/
        System.out.println(100);
        System.out.println(-100);
        /*浮点数常量*/
        System.out.println(3.14);
        System.out.println(0.618);
        /*布尔类型*/
        System.out.println(true);
        System.out.println(false);
        /*字符串常量*/
        System.out.println("你好");
        /*字符常量*/
        System.out.println('A');
        System.out.println('a');
        System.out.println('1');
    }
}
5.2编码集
UTF-8 万国码
	支持世界上通用文字,也是后期开发中会使用的到的编码
	JavaWEB项目 HTML前端页面 数据库软件编码集全部都是对应的     UTF-8
ASCII码  
   关注点:1.大写英文字母编码集编号是小于小写字母
          2.大小写之间非连续
          3. 0 ~ 31字符是不可见字符 
          4. 【重点】任何时候使用字符常量有且只能是'字符本身'
5.3常量总结
常量在代码中是无法修改的量,主要功能是提供给程序运行使用的数据,存在整数,小数,布尔类型,字符常量,字符串常量。
   
	 【重点】字符使用不允许使用字符对应的编码,有且只能使用字符本身!!!

6.变量【伪重点】

Java中定义变量的格式规范
规范:
	数据类型 变量名 = 对应数据类型的初始化数据;
数据类型:
	告知开发者,编译器,当前变量中保存的数据类型是什么?
	【数据类型一致化】

变量名:
	对于当前变量的称呼,可以更好的使用当前变量

=:
	赋值号!!!赋值号右侧的数据,赋值给左侧的【变量】
	
对应数据类型的初始化数据:
	考虑数据类型一致化的情况下,给予当前变量一个初始化数据。

7.数据类型【重点】

八大基本数据类型!!!

5.3.1 整型
整型占用内存空间大小数据范围
byte1字节(8bit)-128 ~ 127
short2字节(16bit)-32768 ~ 32767
int4字节(32bit)-2^31 ~ 2^31 - 1
long8字节(64bit)-2^63 ~ 2^63 - 1
5.3.2 浮点型
浮点型占用内存空间大小数据范围
float4字节(32bit)±3.4*10^38
double8字节(64bit)±10^308
5.3.3 字符型
字符型占用内存空间大小数据范围
char2字节(16bit)能够保存中文
5.3.4 布尔类型
布尔类型占用内存空间大小数据范围
boolean视情况而定true,false

8 变量名/标识符规范【重点】

举例:在注册邮箱时,可以发现邮箱中有要求
	 6~18字符,可以使用字母,数字,下划线,要求必须是字母开头
	 以下规范参考AJCG 阿里巴巴Java开发手册,码出规范,码出高效。

什么是标识符
	程序员自己对于代码中一些内容起的名字,变量名,方法名,类名...

规范
	1. Java中的标识符有且只能使用英文字母(A ~ Z a ~ z), 数字(0 ~ 9) 以及唯一可以使用的标点符号 
	   下划线_ 。其他任何字符都不可以使用!!!
	2. 标识符要求英文字母开头。
	3. 标识符没有严格的长度限制,但是会根据实际的使用情况来约束标识符长度
	4. Java中的标识符严格区分大小写
	5. 标识符要符合【见名知意,动宾结构】
		推荐方式
			getStudentAge setStudentAge
        	studentScore studentGender
        不允许
        	lg lp yy nn ez gjz 采用拼音简写及全拼是不允许的!!!
        	
     6. 标识符要求符合一定的命名要求
		a. 驼峰命名法:
			小驼峰
				一般用于变量名,方法名
				首字母小写,之后的每一个单词首字母大写
				getStudentAge setStudentAge
        		studentScore  studentGender
			大驼峰
				一般用于类名,接口名
				所有单词首字母大写
				FirstJava Demo1  Person UserService
				StudentDao
		 b. 下划线命名法:
        	一般用于Java中的常量
        	MAX_VALUE  最大值
        	DEFAULT_CAPACITY 默认容量
        	
		7. Java中已经被占用的关键字和保留字不能用于自定义标识符
		变颜色的都不可以使用	
        

9.Java中定义变量使用

9.1整型变量演示
/*整型变量演示*/
class Demo3 {
    public static void main(String[] args) {
        /*数据类型 变量名 = 初始化数据*/
        byte byteNumber = 10;//数据范围-128~127 1个字节8个bit位
        short shortNumber = 20;//-32768~32767 2个字节16个bit位
        int intNumber = 30; //4个字节 32个bit位
        // 40L是告知编译器这里是一个long类型
        long longNumber = 40L;//8个字节 64个bit位
        
        // 使用对应变量,直接使用变量名即可!!!
        System.out.println(byteNumber);
        System.out.println(shorter);
        System.out.println(intmber);
        System.out.println(longber);
    }
}
9.2浮点型变量演示
class Demo4 {
    public static void main(String[] args) {
        float floatNumber = 3.14F;
        /*Demo4.java:4: 错误: 不兼容的类型: 从double转换到float可能会有损失
                float floatNumber = 3.14;
                                    ^
		1 个错误
		计算机保存数据,考虑第一原则是数据的精度,double类型精度
		是远远高于float类型,计算机会将所有的小数都看作是double
		类型数据。3.14默认为double类型,这里赋值给float是存在精度
		不一致报错。
		这里需要告知计算机,这里3.14是一个float类型,在3.14之后
		加上一个大写F
			float floatNumber = 3.14F;
			*/
        double doubleNumber = 0.618;
        System.out.println(floatNumber);
        System.out.println(doubleNumber);
    }
}
9.3字符型变量演示
class Demo5 {
    public static void main(String[] args) {
        /* 要求字符类型的常量有且只能使用字符本身 */
        char ch1 = 'A';
        char ch2 = '我';
        System.out.println(ch1);
        System.out.println(ch2);
    }
}
9.4错误演示
class Demo7 {
	public static void main(String[] args) {
		int num1 = 10;
		
		/* 没有定义num2变量
		Demo7.java:14: 错误: 找不到符号
                System.out.println(num2);
                                   ^
		  符号:   变量 num2
		  位置: 类 Demo7
		1 个错误
		*/
		// System.out.println(num2);
		
		int num3;
		
		/* num3变量未赋值初始化
		Demo7.java:24: 错误: 可能尚未初始化变量num3
                System.out.println(num3);
                                   ^
		1 个错误
		*/
		System.out.println(num3);
	}
}
9.5变量定义总结
1. 变量定义一行只定义一个,并且初始化操作,赋予当前变量一个符合当前数据类型的初值

2. 使用对应变量,直接使用变量名即可!!!
    
3.double类型到float类型精度丢失问题
    Demo4.java:4: 错误: 不兼容的类型:double转换到float可能会有损失
            float floatNumber = 3.14;
                                ^
    1 个错误
    计算机保存数据,考虑第一原则是数据的精度,double类型精度
    是远远高于float类型,计算机会将所有的小数都看作是double
    类型数据。3.14默认为double类型,这里赋值给float是存在精度
    不一致报错。
    这里需要告知计算机,这里3.14是一个float类型,在3.14之后
    加上一个大写F
        float floatNumber = 3.14F;

4. 【推荐】
	保证数据类型一致化,在给long类型变量赋值时加上一个大写L,告知编译器这里使用的是一个long类型数据

5. 要求字符类型的常量有且只能使用字符本身

6. 变量名未定义不能使用

7. Java中变量未赋值不能使用

3.Day03.运算符

3.1算术运算符

开发中使用的算术运算符:
    加(+)减(-)乘(*)除(/)取余(%)小括号() 赋值号(=)
注意事项:
    1.先乘除后加减
    2.从左至右运行
    3.除数不能为0
    4.有小括号先运算小括号里面的内容
    【重点】
        1.java中所有的运算符优先等级有18-19个等级,优先级最高的是小括
        号。开发中,如果出现了需要整理优先级的问题,简单粗暴加括号
        2.小括号里面的内容对于小括号外部而言是一个整体,是一个【常量】
=  赋值号
    赋值号的功能是将赋值号右侧的数据,赋值给左侧的【变量】
    演示:
        char ch = 'A'; True  
	    10 = 20;       false
	    
使用总结:
	1. 变量有且只能是被赋值之后才可以修改内容,未赋值不能修改
	2. 取余操作注意细节
	      【重点】   取余操作针对整数,小数没有取余操作
/* 算术运算符演示 */
class Demo1 {
	public static void main(String[] args) {
		// 定义两个int类型变量
		int num1 = 10;
		int num2 = 20;
		
		// num1 + num2结果赋值给num1
		num1 = num1 + num2; // num1 = 30 num2 = 20
		//变量在代码运行的过程中是会发生改变。 
		num1 = num1 * num2; // num1 = 600 num2 = 20
        num1 = num1 - num2; // num1 = 580 num2 = 20
		num1 = num1 / num2; // num1 = 29 num2 = 20
		
        // 小学手写方式
		// 20 ÷ 29 = 0 ...... 20
		// 5 ÷ 2 = 2 ...... 1
        // 9 ÷ 4 = 2 ...... 1
		num1 = num2 % num1; // num1 = 20 num2 = 20
		
		/*
		  变量变量既会发生改变的量
		num1在代码运行中被不断的重新赋值,num1在发生改变
		num2的值从开始到最后没有发生改变
			num2从开始赋值到结束没有被重新赋值过
		*/
		System.out.println(num1);
		System.out.println(num2);
	}
}

3.2偷懒专用算术运算符

非常实用!!!
	+=  -=   /=   *=   %=
	演示:
	  num1 = num1 + num2; ==> num1 += num2;
/* 偷懒专用算术运算符 */
class Demo2 {
	public static void main(String[] args) {
		// 定义两个变量
		int num1 = 10;
		int num2 = 20;
		
		// num1 = num1 + num2; 
		num1 += num2;//num1 = 30;num2 = 20;
        
        // num1 = num1 * num2; num1被重新赋值过
		num1 *= num2; 
		
		System.out.println(num1);//num1 = 600;
		System.out.println(num2);//num2 = 20;
	}
}

3.3关系运算符

代码开发中关系运算符
	>    大于
    <    小于
    >=   大于等于
    <=   小于等于
    !=   不等于
    ==   等于判断

注意事项:
	1. 关系运算符结果是一个boolean数据类型,true or false
	2. 关系运算符一般用于条件判断,数据过滤...
/* 关系运算符 */
class Demo3 {
	public static void main(String[] args) {
		// 定义一个boolean 类型变量
		boolean ret = true;
		
		// 5 > 10 结果赋值给ret 这个boolean类型变量
		ret = 5 > 10;
		System.out.println(ret); // false
		
		ret = 5 < 10;
		System.out.println(ret); // true
		
		ret = 5 >= 5;
		System.out.println(ret); // true
		
		ret = 5 <= 2;
		System.out.println(ret); // false
		
		ret = 5 != 5;
		System.out.println(ret); // false
		
		ret = 5 == 4;
		System.out.println(ret); // false
	}
}

3.4自增自减运算符【难点 考点】

【明确】
	自增自减运算符【有且只能操作变量】,不可以操作常量
【建议】
	开发中尽量减少或者标准化使用自增自减运算符。
	
语法
	++ 自增运算符 操作的变量自增1 等价于 += 1
	-- 自减运算符 操作的变量自减1 等价于 -= 1

【难点】
	前后关系
	自增自减运算符在
		变量之前:首先执行自增自减操作,再来完成当前行代码的运行
		变量之后:首先执行当前行代码,再来执行自增自减操作

【16岁老程序员给你的建议】
	    1. 尽量使用 += 1 或者 -= 1替换自增自减运算符。阅读性更好,并且在Swift语言中已经取消自增自减运算符,使用 += 1 和 -= 1代替,为了避免没有必要的歧义性
	    
        2. 如果非要使用自增自减运算符,推荐自增自减运算符,单独成行。
    	int num = 10;
    	++num; or num++; 没有任何的歧义性 因为单独成行下行代码已经进行完自增运算
/* 自增运算符前后关系演示 */
class Demo4 {
	public static void main(String[] args) {
		int num1 = 10;
		
		// 双引号内容是所见即所得
		/*
		自增运算符在操作数之后,首先操作数原始数据参与该行代码运行
		当前代码运行结束之后,再进行自增操作。
		先执行当前行代码,再执行自增操作
		*/
		System.out.println("num1++ : " + num1++); // num1++ : 10
		System.out.println("num1 : " + num1); // num1 : 11
		
		/*
		自增运算符在操作数之前,首先执行自增操作,num1 += 1;
		num1 ==> 12 然后在进行数据展示
		先执行自增,在参与当前行代码执行
		*/
		System.out.println("++num1 : " + ++num1); // ++num1 : 12
		System.out.println("num1 : " + num1); // num1 : 12
	}
}
/* 自减运算符演示 */
class Demo5 {
   public static void main(String[] args) {
   	int num = 10;
   	
   	System.out.println("num-- : " + num--); // num-- : 10
   	System.out.println("num : " + num); //  num : 9
   	
   	System.out.println("--num : " + --num); // num-- : 8
   	System.out.println("num : " + num); //  num : 8	
   }
}

【自增自减运算符考点】

常见考题1
int num = 5;
int ret = num++ * ++num;

ret = ?
num = ?
/*
请问num值经历了几次自增操作?
	两次,num确定最后结果为7

ret的结果从何而来?
	num++ 
		++在后,提供的数据5, num++在运行表达式中提供的数据为5
		这里运算操作是一个乘以操作,num++需要执行完毕 num ==> 6
	*
	++num:
		++在前,提供的数据6 + 1 ==> 7
    
    最终表达式的结果为
    	5 * 7 = 35 ==> ret;
    	
int ret = num++ * ++num;拆解
	num == 5;
	num += 1 ==> 6
	*
	++num ==> 7
*/
常见考题2
int num = 5;
++(num++);

num = ?;
/*
Demo7.java:5: 错误: 意外的类型
                ++(num++);
                      ^
		  需要: 变量
		  找到:    值
		1 个错误
解释:
	因为(num++)是存在于小括号以内,按照计算优先级处理,首先计算小括号里面的内容,但是因为小括号是一个整体,对外的数据时num++的结果,这是一个常量!!!
	自增自减运算符,只能操作变量,不可以操作常量。
	语法报错!!!
	
同理
	++num++ 也是错误的
	++num结果是一个常量
	
	(num)这个是常量还是变量呢
	这个小括号是无用的!!!
	(num)++这是对的
	
	num = 5
	拿++num*++num = 42
	
	5 
	num++ + --num + ++num 
	结果为16 从何而来?
	num++ 
		num++ 
		++在后,提供的数据5, num++在运行表达式中提供的数据为5
		这里运算操作是一个加法操作,num++需要执行完毕 num ==> 6
		--num
		--在前提供的数据6 - 1 ==> 5 
		++num
		++在前提供数据5 +1 ==>6
		终表达式的结果为
    	5+5+6 ==>16
    5 
	num++ + --num + num++    结果为15
*/

3.5逻辑运算符

与
	银行的金库,两个人两把钥匙,需要同时在场,缺一不可。
	&&  满足两个或多个条件
	【重点】同真为真,有假【即】假
	
或
	自己家门,我和我女朋友出去逛街,只要有一个人带有钥匙就可以回家。
	||   满足一个条件即可
	【重点】有真【即】真,同假为假
	
非
	强牛 
	犟,杠精!!
	取反
	!   强行取反

逻辑运算符运算的结果都是boolean类型数据。
	通常用于条件判断,数据过滤...
	
/* 逻辑运算符演示 */
class Demo8 {
	public static void main(String[] args) {
		// 定义一个boolean类型的变量
		boolean ret = false;
        
		//&& 两个条件同时满足 true
		ret = 5 > 3 && 10 > 8;
		System.out.println("ret : " + ret); // true
		
		ret = 5 < 3 && 10 > 8;
		System.out.println("ret : " + ret); // false
		
        //||两个条件满足一个即可 true
		ret = 5 < 3 || 10 > 8;
		System.out.println("ret : " + ret); // true
		
		ret = 5 < 3 || 10 < 8;
		System.out.println("ret : " + ret); // false
		
        ret = !(5 > 3);//true 取反
		System.out.println("ret : " + ret); // false
	}
}

3.6逻辑运算符短路原则问题

/* 逻辑与短路原则 */
class Demo9 {
	public static void main(String[] args) {
		int num = 5;
		boolean ret = false;
		
		/*
		只要有错后面的就不看了吗 为了效率是吗
		
		逻辑与的情况下:
			同真为真,有假【即】假
			当出现一个条件为false之后,整个逻辑与表达式的结果为
			false,从false之后的其他所有条件都不会执行。
			
			计算机的节约性能问题!!!
		*/
		ret = num > 10 && ++num > 1;
		
		System.out.println("ret : " + ret);
		System.out.println("num : " + num);		
	}
}
/* 逻辑或短路原则问题 */
class Demo10 {
	public static void main(String[] args) {
		int num = 10;
		boolean ret = false;
		
		/*
		逻辑或短路原则
			有【真】即真,同假为假
			只要发现一个条件为真,整个表达式结果已经确定为真。
			从true条件开始其他条件不需要执行
		*/
		ret = num > 5 || ++num > 20;
		
		System.out.println("ret : " + ret); // true
		System.out.println("num : " + num); // 10
	}
}

3.7运算符练习

/*
条件:
	写出判断是否是英文大写字母的条件
	在使用字符常量时,请使用字符本身
*/
char ch; // 声明一个变量
ch >= 'A' && ch <= 'Z';
// 'A' <= ch <= 'Z';  // 计算机不承认这样的写法!!! ERROR
/*
条件:
	写出判断是否是英文小写写字母的条件
	在使用字符常量时,请使用字符本身
*/
char ch; // 申明一个变量
ch >= 'a' && ch <= 'z';
/*
条件:
	写出判断是否是英文字母的条件
*/
char ch;

(ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z');
ch >= 'A' && ch <= 'Z' || ch >= 'a' && ch <= 'z';
/*
以上两种写法结果一致
	按照Java规范的运算符优先级问题,&& 高于 || 
	使用小括号是将条件作出一个整体!!!便于阅读和整理思路
*/
/*
闰年问题:
	1. 能被4整除,但是不能被100整除
	2. 能被400整除
*/
int year;
// 能被4整除
year % 4 == 0;

// 不能被100整除
year % 100 != 0;

// 能被400整除
year % 400 == 0;

// 以上三个条件如何组合?
(year % 4 == 0 && year % 100 != 0) || year % 400 == 0;
/*
加上小括号是一个整体,增强阅读性!!!
*/

作业练习阅读理解:

   ret = 10 % 20
   // 10÷ 20= 0 ...... 10
	ret = 10;
小练习
	1. 写出判断【数字字符】的条件
	/*数字字符 单个元素的称为字符 所以为 0~9*/
	boolean ret = true;
	    //声明一个变量
		char ch ='5';
		
		ret1 = (ch >= '0' && ch <='9');
		System.out.println(ret);
		
	2. 写出判断数值0 ~ 9的条件
	
	boolean ret2 = false;
	
		//声明一个变量
		int num = 7;
		
		ret2 = (num >= 0 && num <=9);
		System.out.println(ret2);
	
	3. 代码阅读 
		int num = 5;
		int ret = num++ - num++;
		ret ? num ?
阅读理解:
		num++ 
		++在后,提供的数据5, num++在运行表达式中提供的数据为5
		这里运算操作是一个减法操作,num++需要执行完毕 num ==> 6
		++num
		++在后提供的数据6 
		
		终表达式的结果为
    	5-6 ==>-1 
    	  ret=-1      输出num 继续执行递增num = 7
	
	4. 代码阅读
		int num = 10;
		int ret = ++num % num--;
		ret ? num?
		
阅读理解:
		++num
		++在前提供的数据为11
		
		--num
		--后提供的数据11
		
		终表达式的结果为
		    11 % 11 = 0  即ret = 0; 输出num继续执行递减 num=10
		    
	5.  代码阅读
		int num1 = 10;
		int num2 = 20;
		int ret = num1 % num2;
		ret = ?

		
		ret = num1 / num2;
		ret = ?
阅读理解:
       ret = 10 % 20
       // 10÷ 20= 0 ...... 10
		ret = 10;
阅读理解:		
		ret = 10/20 结果为小数抹去 为0
		
		ret = 0;;
		
		
		
		
		
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值