北京尚学堂JAVASE课程
北京尚学堂JAVASE课程
一、java历史-特点
1.计算机语言发展史
何为要发明计算机:为了进行科学计算,复杂的科学计算。 人类如何和计算机沟通,去分配任务。 通过计算机语言 实现 人类和计算机的交流。 计算机语言的发展史: 大概的经历了三个阶段 1:机器语言:计算机可以直接识别的语言。 计算机可以直接识别的语言是二进制的语言。 任何的计算机系统都有自己的指令的集合。计算机只能识别自己的指令集合中的二进制指令形式。 0101 1 + 1 +:1010 1010 0001 0001 优点:运行的效率快。 缺点:可读性很差,编写程序的门槛很高。 2:汇编语言:指令集中每一个指令都使用了一个 字符序列来代替。 1 + 1 ADD 0001 0001 糖语法 优点:代码可读性增强了,指令也更容易记忆了。 缺点:多了一个编译的过程。 3:高级语言: c c++ java c# 1 + 1 优点:开发的效率高了,可读性好了。学习的门槛降低了。 缺点:需要将更高级的语法转换为 机器语言的形式。(编译 or 解释)。影响了最终的效率。
2.java历史和版本
1991年,Sun公司的Green项目,Oak 1995年,推出Java测试版 1996年,JDK1.0 1997年,JDK1.1 1998年,JDK1.2,大大改进了早期版本的缺陷,是一个革命性的版本,更名为Java2 1999 Java被分成J2SE、J2EE 和J2ME,JSP/Servlet技术诞生 J2SE:java 2 standard edtion。针对客户端,桌面程序开发的。标准版。 J2EE:java 2 Enterprise edtion 针对服务器端开发的。企业版。 J2ME:java 2 micro edtion 针对手持设备开发的。微型版。 2004年,J2SE 5.0 (1.5.0) Tiger老虎.为了表示这个版本的重要性,J2SE1.5更名为J2SE5.0。 2006年,J2SE 6.0 (1.6.0) Mustang野马.此时,Java的各种版本被更名,取消其中的数字"2":J2EE更名为Java EE, J2SE更名为Java SE,J2ME更名为Java ME 2009年4月20日甲骨文收购Sun公司,交易价格达74亿美元 2011年,JavaSE7.0 2014年,JavaSE8.0
3.java特点
了解
特点:
Java是简单的:
不再有#include 和#define 等预处理功能
不再有struct,union及typedef
不再有函数、
不再有指针、不再有多重继承
不再有goto
不再有操作符重载(Operatior Overloading)
不再有全局变量 取消自动类型转换,要求强制转换
不再有手动内存管理
Java是安全的:取消了指针,自动内存回收。
Java是完全面向对象的:继承、封装、多态
Java是健壮的:Java的强制类型机制、异常处理、垃圾的自动收集等是Java程序健壮性的重要保证
java 最大的特点和优势。
java 的跨平台。
4.java跨平台原理
1) C/C++语言都直接编译成针对特定平台机器码。如果要跨平台,需要使用相应的编译器重新编译。
2) Java源程序(.java)要先编译成与平台无关的字节码文件(.class),然后字节码文件再解释成机器码运行。解释是通过Java虚拟机来执行的。
3) 字节码文件不面向任何具体平台,只面向虚拟机。
4) Java虚拟机是可运行Java字节码文件的虚拟计算机。不同平台的虚拟机是不同的,但它们都提供了相同的接口。
5) Java语言具有一次编译,到处运行的特点。就是说编译后的.class可以跨平台运行,前提是该平台具有相应的Java虚拟机。但是性能比C/C++要低。
6) Java的跨平台原理决定了其性能没有C/C++高
5.jvm 的作用简介
jvm:java virtual machine。
作用:
1:jvm 负责管理内存。分配内存,回收内存。
2:程序代码的加载。
3:解释字节码到机器码给cpu去执行。
6.jdk
jdk: java development toolkit
java 开发工具包。
需要的开发的主要的工具:编写代码的环境(记事本)、编译的环境(编译器)、解释执行的环境(解释器)。
jdk 安装好之后,编译的环境,还有运行的环境 jvm 都安装完毕。
jre:java runtime environment。java 运行环境。
jdk 目录:
bin: binary javac.exe 编译工具 java.exe 解释器
安装jdk的要求:
安装 jdk1.8 版本。
不要安装多个 jdk 版本。
最好默认安装。
7.dos
1:编写源代码 注意保存。 ctrl+s
2: 使用编译器 javac.exe 编译源代码。
要借住 cmd 窗口。来使用编译器 编译源代码。
dos: disk operating system 磁盘操作系统。
在 windows 系统下 的 cmd.exe 可执行文件,是使用软件模拟的 dos 操作系统。
dos:是一个靠命令行来完成所有的操作的系统。
如何在windows 平台上 运行 dos 界面程序
cmd:command
1: 在开始菜单搜索处输入cmd 回车即可。
2:按windows键+R键 弹出 运行界面,输入cmd 回车。
内部指令:属于cmd 程序的内部的指令,内置指令。随着cmd 的启动就可以直接使用了。
外部指令:通常对应着磁盘上的一个可执行的文件。
要通过cmd 窗口 运行使用 javac.exe ???
认识 dos 操作系统的一些常用的指令
可以通过 指令 /? 了解当前指令的用法
例如:cd /? 回车
1:切换目录的指令
cd (change dirctory).
chdir
cd \ 回到当前目录的根目录。
2:切换盘符:盘符:回车
.. :代表当前目录的上一级目录
. :代表当前目录
3:dir (dirctory):显示当前目录下的所有的文件和目录的。
4:cls 清屏 clear screen
5:start: 开启另外一个dos窗口
6 : exit 退出当前dos窗口
了解
7:md | mkdir 创建目录
8:rd /s /q 目录
9:del 删除文件
del 删除所有文件 del *.* :
* 通配符 代表任意个字符
?:代表一个字符
10:copy 复制文件 copy 源文件路径 目的路径
copy c:\class\a.java d:\class\b.java
11 : move 剪切。
12 : ren 重命名 ren 源文件名字 新文件名字
快捷键:
TAB:自动补齐
上下箭头:快速使用之前使用过的命令。
8.第一个java程序
通过 dos 窗口 编译源代码。 javac HelloWorld.java 回车:首先会在当前目录下找javac.exe ,如果当前目录下没有,会去环境变量 配置的path 的一个目录集合中去挨个查找。 配置环境变量 path。将 javac.exe 所在的目录添加到 path 中去。 配置环境变量的作用: 建议只配置path。 为了在 cmd 窗口中可以直接使用 javac 和 java 外部命令。 public class HelloWorld{ public static void main(String[] args){ System.out.println("Hello World!"); } } public:java 的权限修饰符。 class:java的关键字 HelloWorld:类的名字,首字符大写。 public static void main(String[] args):入口方法,main 方法。格式是固定的。程序开始执行的地方。 将需要执行的代码 写到 main 方法中。 System.out.println("Hello World!"); 将双引号中的内容(字符串)原样输出到cmd 窗口。还输出了一个换行符。 如何配置环境变量: 我的电脑-->右键属性-->高级系统设置-->环境变量--->在path 的末尾 添加 javac 编译程序所在的 目录的 bin目录。使用 半角分号 分割不同的目录。 如何编译和运行java 程序。 在 cmd 窗口中。首先要切换到 源代码所在的目录(使用英文目录)。然后使用 在命令行输入 javac HelloWorld.java 回车。 会生成一个.class 文件。 如果编译不成功。需要修改源代码。切记保存。重新编译。javac HelloWorld.java 回车。 然后,解释执行 class 命令行:java HelloWorld 回车。 public class Introduce{ public static void main(String[] args){ System.out.println("我是小杨老师!~"); System.out.println("我是沧州人士!自幼习武!中途放弃!"); System.out.println("欢迎大家来到北京尚学堂学习!"); System.out.println("希望大家在接下来的时间里,好好学习,天天向上!不搞对象!"); System.out.println("将来毕业找一个满意的工作,实现人生的理想!然后迎娶白富美,走向人生的巅峰!"); } }
9.修改cmd 启动默认路径
windows 键+ R
输入:regedit 回车。
HKEY_CURRENT_USER--->Software--->microsoft--->Command Processor
autorun-->cd /d 目录
二、计算机其他知识
1.进制
public class SystemTest{ public static void main(String[] args){ System.out.println(10);//直接书写一个数字,那么默认为10进制。 System.out.println(0b1010);//二进制 高位添加 0b jdk1.7开始支持二进制 System.out.println(012);//八进制 高位添加0 System.out.println(0xa);//十六进制 高位添加0x } } 四种进制的特点: 十进制:逢十进一,每一位上出现的数值的取值范围[0-9] 二进制:逢二进一,每一位上出现的数值的取值范围[0-1] 计算机底层使用二进制表示所有的数据。 八进制:逢八进一,每一位上出现的数值的取值范围[0-7] 十六进制:逢十六进一,每一位上出现的数值的取值范围[0-15] 必须使用一个字符表示[10-15] [a-f][A-F] 二进制: 一位二进制位 有两种状态 0、1。称之为1 bit。 1bit 是计算机中最小的存储单元了。 8 bits-->1 byte 1024 bytes--->1 KB 1024 KB--->1 MB 1024 MB--->1 GB 1024 GB--->1 TB 1024 TB--->1 PB 计算机通常使用字节为单位来处理数据。 使用四种进制来表示 0-15 二进制 八进制 十进制 十六进制 000 0 0 0 001 1 1 1 010 2 2 2 011 3 3 3 100 4 4 4 101 5 5 5 110 6 6 6 111 7 7 7 1000 10 8 8 1001 11 9 9 1010 12 10 a 1011 13 11 b 1100 14 12 c 1101 15 13 d 1110 16 14 e 1111 17 15 f 10000 20 16 10 10001 21 17 11 10010 22 18 12 1个二进制位 能表示2种状态。 2个二进制位 能表示4种状态。 3个二进制位 能表示8种状态。 4个二进制位 能表示16种状态。 n个二进制位 能表示2的n次幂种状态。
2.机器码-原码-反码-补码
对于任何的一个整数,在计算机中的存储的具体的表示形式?
二进制的机器码的表示形式??
定义了三种码制来表示一个数据
不同的码制代表着不同的表示机器码的规则。
原码:
规则:最高位为符号位,最左边的一个二进制位 为 符号位 。0 代表是正数。1 代表负数。剩下的二进制位数为数值位。表示数值的大小。
10:00001010
-10:10001010
计算机不使用原码来最终的表示一个数据。
原因:
1: +0 -0 00000000 10000000 原码形式有+0 和 -0之分。
2:设计cpu的时候需要考虑符号位的设计,大大加重了设计cpu的难度。
反码:
规则:
正数:如果是一个正数,那么反码和原码一致。
负数:符号位不变,其余的数值位1-->0 0-->1
-10: 1000 1010--->1111 0101
补码:
规则:
正数:补码和原码一致。三码合一。
负数:先求原码,再求反码,然后再 加1.
-10: 1000 1010--->1111 0101--->1111 0110
-1: 1000 0001--->1111 1110---> 1111 1111
计算机广泛的采用补码的形式来表示数据:
原因:
1:没有 +0 和 -0 之分。
0000 0000
1000 0000-->1111 1111--> 1 0000 0000
2:计算机的cpu 在进行数据运算的时候,补码的符号位 并没有被看作符号位。符号位的运算的规则和普通的数值位的运算的规则一致。
简化了cpu的设计。
规则:补码的补码是原码。
对补码 取反 +1 就是该补码的原码形式。
-1:1111 1111 ---> 1000 0000 --->1000 0001
3.练习
需求:使用四种进制来表示10并打印输出,并把-1的二进制字符串形式打印 //10使用四种进制来表示输出 public class SystemTest{//18 public static void main(String[] args){ System.out.println(10);//直接书写一个数字,那么默认为10进制。 System.out.println(0b1010);//二进制 高位添加 0b jdk1.7开始支持二进制 System.out.println(012);//八进制 高位添加0 System.out.println(0xa);//十六进制 高位添加0x //将-10 的二进制的字符串的形式打印 System.out.println(Integer.toBinaryString(-1));//1111111111111111111111110110 System.out.println(Integer.toBinaryString(-10).length());//32 } }
4.进制的转换
各种进制之间相互的转换:
各种进制到十进制的转换:
123 = 1*10^2 + 2 * 10^1 + 3 * 10^0 = 100 + 20 + 3
0b1010110 = 2^1 + 2^2 + 2^4 + 2^6 = 2 + 4 + 16 + 64 = 86
0765 = 5 + 6 * 8 + 7 * 64 = 5 + 48 + 448 = 501
0x1ad = 13 + 10*16 + 256 = 13+160+256 = 429
十进制到其他进制的转换
10-->2
除二取余法:
2<--->8
三个二进制位对应一个八进制位
0b1100110--->0146
0561--->101110001
2<--->16
四个二进制位对应一个16进制位。
101110001-->171
三、标识符-数据类型-变量
1.标识符
a b 3a _3 public1。
age
name
studentScore
stuScore
标识符的命名规范的基本的规范:
1:见名知意。通过名字能体现对应的内存区域的数据的内容。
2:驼峰命名法。多个单词构成的标识符,单词的首字符大写。
3:避免使用单字符标识符。
目前位置接触过的java 关键字
public class static void
2.数据类型
java 程序中支持哪些数据类型。
java 是一种强类型语言。所有的数据:标识符以及 字面的常量数据都是有类型的。
数据的具体类型有2种指定的方式:
1:显式指定。
2:隐式指定。通常是针对字面值。由编译器默认指定。
整数的默认类型为 int。
浮点数的默认类型为 double
'A' 字符类型
true false boolean
"afdf" 字符串
java 支持的数据类型:
分为2大类:基本数据类型、引用数据类型。
基本数据类型:java 内置类型、简单数据类型。
1:4个整数类型
字节型 byte 8bits 1个字节 取值范围[-128~127]
短整型 short 16bits 2个字节 取值范围[-2^15 ~ 2 ^15 -1]
整型 int 32bits 4个字节 取值范围[-2^31 ~ 2 ^31 -1]
长整型 long 64bits 8个字节 取值范围[-2^63 ~ 2 ^63 -1]
2:2个浮点数类型
单精度 float 32bits 4个字节 小数点后可以保留7位。 一共有8个有效数字。
双精度 double 64bits 8个字节 小数点后可以保留16位。 一共有17个有效数字。
3:1个字符类型
字符 char 16bits 2个字节 [0~65535]
4: 1个布尔类型
布尔 boolean ??? 只有两个值 true false。
引用数据类型:复合数据类型、复杂数据类型
3个引用数据类型:
类: class
接口:interface
数组:[]
类型的作用:
1:决定了占用内存空间的大小。
2:底层的存储的格式
3:决定了最终显式的形式。
3.变量
变量:Variable。 概念:变量的本质是一块内存区域,该内存区域中的值可以被修改。 局部变量:在方法内部定义的变量,称为局部变量。 局部变量定义的语法: 变量类型 变量名 = 初始值; 变量类型:java支持的任意类型。 变量名:合法的标识符 定义变量可以分为2步进行: 变量类型 变量名;---->变量的声明 变量名 = 初始值;---->变量的赋初值 变量的定义=======变量的声明+赋初值 局部变量的特点: 局部变量必须先定义后使用。 局部变量的内存在栈中分配。 //定义一个标识符,名字为 age,并给age 标识符对应的内存存一个short类型的值。 public class SimpleTypeTest{//18 public static void main(String[] args){ //数据的类型 标识符名字 = 初始值。 //向jvm 申请一块内存,名字为age ,内存中的数据的类型为 short。占用2个byte。 short age = 19; System.out.println(age); //定义标识符 用来存储 高考的分数 int 、圆周率 double 、班级中是否有女生 boolean。将内存中的数据全部依次打印。 int score = 555; double pi = 3.1415926; boolean isGirlInClass = true; System.out.println(score); System.out.println(pi); System.out.println(isGirlInClass); // int weight; weight = 68; System.out.println(weight);//获取变量的值 //weight = 70; weight = weight + 2; System.out.println(weight);//获取变量的值 } }
4.变量的定义的各种语法
//变量的各种语法定义 public class VariableTest{//18 public static void main(String[] args){ int a1 = 10; int a2 = 20; int b1 = 10, b2 = 20, b3 = 10; int c1, c2, c3; c1 = 32; c2 = 45; c3 = 67; int d1, d2 = 34, d3; } }
5.局部变量的内存分析![](https://images2018.cnblogs.com/blog/1468415/201808/1468415-20180818153855367-872964957.png)
6.常量
java 中的常量 分为两种。 1:字面常量。通过数值的字面就可以知道数值的大小。 字面常量有默认类型,类型由 编译器 指定。 整数的默认类型为 int。如果超过了int 的范围,需要在末尾添加 L or l 来告诉编译器 当long类型来处理。 浮点数的默认类型为 double。如果一个浮点数常量需要当作 float 来对待,那么需要在末尾添加 F or f。 true false,默认是 boolean "字符串" 'A' 字符 2:不可变的变量。使用 final 关键字 修饰。终态变量。 在变量的类型前添加关键字 final 即可。 特点:只能初始化一次。只有获得变量值的权利,没有修改变量值的权利。 //不可变的变量 final public class FinalTest{//18 public static void main(String[] args){ final double PI = 3.14; System.out.println(PI); //pi = 4.0; final int MAX_AGE; MAX_AGE = 135; } }
7.作用域
作用域:变量可以被访问的范围。
局部代码块:在方法体的内部的一对大括号。
局部代码块中可以写任何的java 代码。
作用:将局部变量的作用域范围控制的更小。
局部变量的作用域范围:从定义的位置开始。到变量所在的大括号的结尾处。
8.字符类型-转义字符
char 类型:可以当作整数来对待。 无符号的短整型。没有负数.取值范围 [0-65535]. 字符集:字符的集合。字符集合中的每一个字符都对应着一个唯一的整数。 ASCII:单字节字符集。只用到了一个字节的后7位。128个字符。 '0'--->48 'A'--->65 'a'--->97 ISO8859-1: 西欧使用的字符集,单字节字符集。256个字符。兼容了ASCII。 gb2312:双字节字符集。兼容了ASCII。主要收录了中文简体。 GBK:兼容了 gb2312.增加了繁体中文,还有各个少数民族的符号。 utf-8:三字节的字符集。兼容了 ASCII。 Unicode:万国码。java 使用的字符集。jvm 使用的。保证所有的国家的符号都能识别。 转义字符: \t:水平制表符 对应着键盘上的Tab键。 作用:\t占用的半角的个数为[1-8].从\t包括之前的输出的内容。总共占用的半角的位数必须是8的倍数。\t用来补齐8个半角位的倍数的。 \b: 退格符: 对应着键盘上的 Backspace 键。 \r: 回车符: 让光标回到当前行的行首,后续的输出从行首输出。 \n: 换行符: 让光标去下一行。 Enter 键对应两个字符:\r\n 让光标去到下一行的行首。 \' :字符单引号。 \" :字符双引号。 \\ :字符反斜杠。 //char 类型 public class CharTest{//18 public static void main(String[] args){ char myChar = 'A'+32;//65 char myChar2 = 48;//0 char myChar3 = '\u0064';//转义序列 System.out.println(myChar); System.out.println(myChar2); System.out.println(myChar3); int age = 19; //字符串可以和任意类型 使用 + 连接符 将字符串和 基本数据类型的数据做连接。然后整体输出 System.out.println("我的年龄:\t" + age); System.out.println("1234\"56789"); System.out.println("\t123456789");//8个 System.out.println("1\t23456789");//7个 System.out.println("1234567\t89");//1 System.out.println("12345678\t9");//8个 System.out.println("1234\r56\n789"); System.out.println('\''); System.out.println('\\'); } }
9.练习-Scanner
//根据键盘输入,输入一个圆的半径,求圆的周长和面积。 //告诉编译器 Scanner 来自哪里 //java.lang 包是java 的核心包。核心包中所有的内容都是被默认导入的。 //* 代表通配符,代表所有。 import java.lang.*;// 这行代码写不写都会存在。 import java.util.Scanner; public class ScannerTest{//18 public static void main(String[] args){ //使用jdk 已经定义好的类。扫描器类。 //创建一个扫描器对象,扫描键盘输入 System.in 对应着我们的标准输入设备-->键盘 //java.util.Scanner scanner = new java.util.Scanner(System.in); Scanner scanner = new Scanner(System.in); //提高用户体验 UE System.out.println("请您输入圆的半径:"); //使用扫描器对象去接收键盘输入的一个整数。并返回该接收到的整数。 int radius = scanner.nextInt();//阻塞式方法。会导致程序的阻塞。解除阻塞之后,程序继续执行。 // 半径、周长、面积、圆周率 //定义变量 //int radius = 7; final double PI = 3.14; double area; double length; //求圆的周长和面积 length = 2 * PI * radius; area = PI * radius * radius; //最后打印输出结果 System.out.println("半径是:"+radius + "\t的圆的周长 = "+length + "\t面积 = "+area); } }
10.Scanner 功能介绍
Scanner scan = new Scanner(System.in);
//hello world
String str = scan.next();//只能获得一个单词的字符串。
String str = scan.nextLine();//得到一行文本。
double dou = scan.nextDouble();// 得到一个双精度的浮点数
float fl = scan.nextFloat();// 得到一个单精度的浮点数
字符串的定义和使用。
int age = 10;
String str = "123";
11.注释
java 中的注释: comment。 注释的作用:可以帮助开发者更好的理解,记忆,阅读程序代码的。 注释部分的内容,不参与编译。 给程序添加合适的注释是作为一个程序员的基本修养。 java中支持的注释的类型: 三种: 1:单行注释: //后面的内容都是注释的内容。 用法: 1:注释的内容单独占用一行,解释下面一行的内容。 2:在一行代码的末尾。添加注释。短注释。一般注释的内容不超过10个字符。 3:将一行代码注释掉,让代码失效的。 2:多行注释: /*注释的内容*/ 用法:多行、单行、一行的一部分。 3:文档注释: /**注释的内容*/ 帮助我们生成代码的阅读文档的。
12.float & double
1:float 和 double 很多时候不能精确的表示一个小数。 3.3 0b0.1--->0.5 0b0.01--->0.25 0b0.001--->0.125 小数点后的第n位上的1 对应的十进制小数的值为 1/2^n float 和 double 不是为了精确运算而设计的。 float 和 double 很多时候只是近似表示 某个小数。 0.3F 0.0101010100000001010101 0.0101010101
四、操作符、运算符
1.算术运算符
1:java 程序支持哪些运算符。可以使用哪些运算符对数据进行计算。 概念: 1:操作数:参与运算的数据 称为操作数。 2:表达式:运算符和操作数的整体 称为表达式。 单独的一个操作数也可以看作一个最简单的表达式。 int age = 1+1; 3:返回值:操作数 或者是 表达式 参与 运算的结果。 注意:参与所有运算的数据,都是操作数 或者 表达式的 返回值 参与的。 4:一元运算符:只需要一个操作数的运算符。也叫做 单目运算符。 5:二元运算符:需要两个操作数的运算符。也叫做 双目运算符。 6:三元运算符:需要三个操作数的运算符。也叫做 三目运算符。 一:算术运算符: + - * / % ++ -- //算术运算符 public class MathTest{ public static void main(String[] args){ int num0 = 10, num1 = 20; //+ 既是一个一元运算符,也是一个二元运算符。 System.out.println(+ num0);//一元运算符 System.out.println(num0 + num1);//二元运算符 //- 既是一个一元运算符,也是一个二元运算符。 System.out.println(- num0);//一元运算符 System.out.println(num0 - num1);//二元运算符 //* 二元运算符 两个操作数的乘积 运算的规则和数学中一样一样的。 System.out.println(num0 * num1);//二元运算符 System.out.println(-num0 * num1);//二元运算符 System.out.println(num0 * -num1);//二元运算符 System.out.println(-num0 * -num1);//二元运算符 // / 二元运算符 两个操作数相除。运算的规则和数学中一样一样的。 //如果两个操作数都是整数,那么结果为相除的整数部分。没有四舍五入。 System.out.println(num0 / num1);//二元运算符 System.out.println(-num0 / num1);//二元运算符 System.out.println(num0 / -num1);//二元运算符 System.out.println(-num0 / -num1);//二元运算符 // % 二元运算符。a%b a除以b 得到的余数 结果的符号位和左边的操作数一致。 System.out.println(5 % 2);//1 System.out.println(-5 % 2);//-1 System.out.println(5 % -2);//1 System.out.println(-5 % -2);//-1 // / 和 % 的应用。 123. int num = 689; int unit = num % 10; int decade = num / 10 % 10; decade = num %100 / 10; int hundred = num / 100; System.out.println(num + "\t的百位:" + hundred + "\t十位:" + decade + "\t个位:" + unit); //自增运算符 ++ :一元运算符 实现对变量自增一的操作。 //两种模式:前缀模式 后缀模式。 num = 0; num = num + 1; ++ num; num ++; System.out.println("num = "+num); //后缀模式:先返回后自增。num++ 表达式的返回值 是 num 自增之前的值。 // num ++ 先计算了得到了返回值。自增之前的值。然后 num 做自增+1操作。然后将 num ++ 之前得到的返回值赋值给 age; int age = num ++; System.out.println("num = "+num + "\tage = "+age); num = 0; num = num ++; System.out.println(num ++ + num ++ + num ++);//3 System.out.println("num = "+num);//3 num = 0; //前缀模式:先自增 后返回 表达式的返回值是 自增之后的值。 System.out.println(num++ + ++num + num ++ - ++num);//0 //自减运算符: -- :一元运算符 实现对变量的自减一 的操作。 //后缀模式:先返回 ,后自减。。前缀模式:先自减后返回。 } }
2.练习
求随机数[100-1000) //获得随机数 public class RandomNumberTest{ public static void main(String[] args){ //得到区间[100-1000) 区间通常是 前闭后开的。前包含,后不包含。 final int MIN = 100; final int MAX = 102; //Math.random() 同样有返回值。返回值是一个随机的double 值。[0.0~1.0) System.out.println(Math.random() * (MAX-MIN) + MIN); //int value = 0; //Math.random() * (MAX-MIN) + MIN [100.0~ 1000.0) 去掉小数 int value = (int)(Math.random() * (MAX-MIN) + MIN); System.out.println("value = "+value); } } //随机得到两个[10-20]的随机数,定义变量保存两个随机数。然后打印该随机数。 //实现交换两个变量的值。 public class ChangeValueTest{ public static void main(String[] args){ //定义区间 final int MIN = 10, MAX = 21; int num1 = (int)(Math.random()*(MAX-MIN)+MIN); int num2 = (int)(Math.random()*(MAX-MIN)+MIN); System.out.println("num = "+num1 + "\tnum2 = "+num2); int temp = num1; num1 = num2; num2 = temp; System.out.println("num = "+num1 + "\tnum2 = "+num2); //使用异或来实现。根据异或的特点实现的。 num1 = num1 ^ num2; num2 = num2 ^ num1; num1 = num1 ^ num2; System.out.println("num = "+num1 + "\tnum2 = "+num2); } }
3.赋值运算符
赋值运算符: =:二元运算符。 赋值 操作 永远是 最后执行。 实现的功能:将右边表达式的返回值 赋值 给 左边的变量(可以是终态变量)。 = 左边 :左值 left value = 右边 :右值 right value 左值:必须是变量 或者是 终态变量。 右值:可以是: 常量 : 1 变量 : age 常量表达式:1 + 1 + 4 变量表达式: x + y 常量、变量表达式:1 + x; 左值的类型 要和 右值表达式的返回值的类型 要兼容。 复合赋值运算符: += -= *= /= %= 复合赋值运算符特点: 1:生成的字节码文件要稍微小一点点。 2:隐含了一个强制类型转换,强制转换的类型为 左边变量的类型。 //复合赋值运算符练习 public class AssignmentTest{ public static void main(String[] args){ int value = 10; //value = value + 10; value += 10; //value = value - 10; value -= 10; //value = value * 10; value *= 10; //value = value /10; value /= 10; //value = value % 10; value %= 10; byte age = 127; //age += 1; age = age + 1; System.out.println("age = "+age); } }
4.关系运算符
关系运算符:表达的是 操作数之间的关系是否成立的。 成立,关系表达式返回值为 true ,否则为 false。 6个关系运算符: > : 大于:二元运算符。左边的操作数是否大于右边的操作数。 < :小于:二元运算符。左边的操作数是否小于右边的操作数。 >=:大于等于:二元运算符。左边的操作数是否大于等于右边的操作数。 <=:小于等于:二元运算符。左边的操作数是否小于等于右边的操作数。 ==:等于:二元运算符。左边的操作数是否等于右边的操作数。 !=:不等于:二元的。左边的操作数是否不等于右边的操作数。 > < >= <= :只适用于 数值型 包括 char 类型的数据。 == != 适用于 java支持的所有的数据类型。 //复合赋值运算符练习 public class RelationTest{ public static void main(String[] args){ int num0 = 0; int num1 = 0; System.out.println(num0 + 1 > num1);//true boolean bool = num0 < ++ num0; System.out.println(bool);//true System.out.println(num0 == num0 ++);//true num0= 0; System.out.println(++num0 != num0 ++);//false float f1 = 11111111111111f; float f2 = 11111111111110f; System.out.println(f1);//1.11111108E13 System.out.println(f2);//1.11111108E13 System.out.println(f1 == f2);//true } }
5.逻辑运算符
逻辑运算符:参与逻辑运算的操作数必须是 boolean 类型的数据。逻辑表达式的 返回值 也是 boolean 类型。 //逻辑运算符练习 public class LogicTest{ public static void main(String[] args){ // & 逻辑与 :二元运算符。规则:有一个操作数是 false 那么结果就是false。两个都是true 的时候,结果才是 true。 // 规律:有假 则 假 ,全真 则真。 表达的关系 是 并且的关系。 System.out.println(true & true);//true System.out.println(true & false);//false System.out.println(false & true);//false System.out.println(false & false);//false System.out.println(); // | 逻辑或:二元运算符。规则:有一个操作数是 true,那么结果就是 true,都是false 结果才是false。 // 规律:有真则真,全假则假。 表达的是或者的关系。 System.out.println(true | true);//true System.out.println(true | false);//true System.out.println(false | true);//true System.out.println(false | false);//false System.out.println(); // ^ 逻辑异或 二元运算符 规则:两个操作数相异为 true 相同为false。 System.out.println(true ^ true);//false System.out.println(true ^ false);//true System.out.println(false ^ true);//true System.out.println(false ^ false);//false System.out.println(); // ! 逻辑非 逻辑取反 一元运算符。规则:true-->false false--->true System.out.println(!true);//false System.out.println(!false);//true System.out.println(); // && 短路与 条件与 System.out.println(true && true);//true System.out.println(true && false);//false System.out.println(false && true);//false System.out.println(false && false);//false System.out.println(); // & 和 && 的区别 // &:进行逻辑与运算的所有的操作数,不管前面的操作数的返回值的结果是否是false,所有的操作数都会进行运算。然后进行逻辑运算。 // &&: 进行 短路与运算的过程中,如果前面有操作数的返回值 是 false。 // 那么后面的所有的操作数将不再计算,直接返回整个逻辑表达式的结果为false。 // 短路与的效率往往高于逻辑与,所以建议使用短路与。 int value = 0; System.out.println( (1>2) && (value ++ > 0));//false System.out.println("value = "+value); // | 和 || 的区别。 // || 如果进行 短路或 运算,如果有一个操作数的结果为 true,那么后续的操作数将不再计算,而直接返回整个逻辑表达式的值 为 true. } }
6.位运算符
位运算符: 直接对底层的二进制位操作,效率相对较高。 位运算的数据的类型:整数、char。 //位运算符练习 public class BitTest{ public static void main(String[] args){ // & 按位与:二元运算符。 规则:低位对齐,进行按位与。 对应的位 有0则0 全1则1. System.out.println(3 & 5);//1 //作用:1:可以将某个整数的某些二进制位设置为0。 //2:可以得到某一个数的制定区间的二进制表示的数据。 // | 按位或: 二元运算符。 规则: 低位对齐,进行按位或。对应的位,有1则1,全0则0 System.out.println(3 | 5);//7 //作用: //1:如果两个操作数 对应的位 上没有全1 的,那么进行按位或 和 加的效果一致。 System.out.println(3 | 4);//7 System.out.println(1 | 2);//3 System.out.println(8 | 16);//24 System.out.println(4 | 8);//12 System.out.println(3 | 12);//15 //让你们找10个数。20个数。使用其中的任意几个数。然后做加法。不会和其他的组合的结果重复。 //1,2,4,8,16,32,64,128,256, //2: 可以让指定的某些二进制位的值设置为1. //按位异或 ^ 二元运算符。。规则:对应的位上 相异为1,相同为0. //特点:一个数先后和同一个数据异或两次,结果是它自身。 System.out.println(3 ^ 4 ^ 4);//3 //简单的加密 char c1 = '我'; char c2 = '爱'; char c3 = '你'; int key = 6666; c1 ^= key; c2 ^= key; c3 ^= key; System.out.println("密文="+c1 + c2 + c3); c1 ^= key; c2 ^= key; c3 ^= key; System.out.println("明文="+c1 + c2 + c3); // ~ 按位取反 一元运算符。规则:所有的二进制位0--->1 1--->0 System.out.println(~0);//-1 //移位运算符。 // >> :带符号右移 :低位被移走,高位空出来的补符号位,正数补0 负数补1. System.out.println(-1>>1);//-1 System.out.println(35>>2);//17 System.out.println(101>>1);//50 System.out.println(89>>4);//5 //应用:对于某个区间的整数,右移动n位,等价于 该数除以 2的n次幂 // << 左移 :高位被移走,包括符号位。低位补0. System.out.println(1<<1);//2 System.out.println(1<<2);//4 System.out.println(1<<3);//8 //应用:在某些区间 左移n位等价于 乘以2的n次幂。 System.out.println(1<<31);//8 // >>> 无符号右移:低位被移走,高位补0. //应用:为了得到一个随机的正整数。 final int MAX = 102, MIN = 100; //创建产生随机数对象ran java.util.Random ran = new java.util.Random(); int value = ran.nextInt();//得到一个随机的int 类型的数据。 System.out.println("value = "+value); //得到了一个随机的正整数 value >>>= 1; //value = value >>> 1; System.out.println("value = "+value); value = value %(MAX-MIN) + MIN; System.out.println("value = "+value); //一句代码实现得到随机数。 value = (ran.nextInt() >>> 1)%(MAX-MIN) + MIN; System.out.println("value = "+value); } }
7.条件运算符
java 中唯一的三目运算符。 需要三个操作数。 语法: 表达式-1 ? 表达式-2 : 表达式-3 解释: 表达式-1:必须是一个 boolean 表达式。返回值是 boolean 值的表达式。 表达式-2、表达式-3:可以是java 支持的任意的表达式。两个表达式的返回值的类型 需要兼容。 执行过程: 1:判断 表达式-1 的结果。如果 结果为 true,那么整个条件表达式 返回 执行 表达式-2 并返回 表达式-2 的结果。 2:如果结果为false,那么跳过 表达式-2,执行表达式-3,并返回 表达式-3 的返回值。
8.运算符的优先级
1:乘除取余 大于 加减。
2:一元运算符 大于 二元运算符 的优先级。
3:二元运算符的优先级高于三元运算符的优先级。
4:赋值运算符优先级最低。
5:配合小括号使用。
9.练习
// 1:得到两个随机数,一个使用Math获得,一个使用Random获得。全部打印。使用三目实现,将比较大的结果求出来。 // 2:得到一个随机数,如果奇数,打印 xxx 是奇数 如果是偶数 ,打印 xxx 是偶数 import java.util.Random; public class ConditionTest{ public static void main(String[] args){ //定义区间 final int MIN = 10, MAX = 111; int num1 = (int)(Math.random()*(MAX-MIN)+MIN); //创建获得随机数的对象 Random ran = new Random(); int num2 = (ran.nextInt()>>>1)%(MAX-MIN)+MIN; int num3 = (int)(Math.random()*(MAX-MIN)+MIN); System.out.println("num = "+num1 + "\tnum2 = "+num2+ "\tnum3 = "+num3); int max = num1 > num2 ? num1 : num2; max = max > num3 ? max : num3; //嵌套的三目 int max1 = num1 > num2 ? (num1 > num3 ? num1 : num3) : (num2 > num3 ? num2 : num3); System.out.println("max = "+max); System.out.println("max1 = "+max1); // String str = max % 2 == 0 ? "偶数" : "奇数"; //(max & 1) == 0 成立,说明 max 的二进制形式的最末位是0 str = (max & 1) == 0 ? "偶数" : "奇数"; System.out.println(max + "\t是"+str); } }
五、基本数据类型转换
1.算术运算时的转换
类型转换: java 不支持 不同类型之间的运算。 如果有不同类型之间的数据做运算的话,那么首先第一步做同类型转换。编译器来完成这种转换的。自动的完成的。 转换的规则: 1:如果参与运算的操作数的类型是如下的类型中的:byte char short int ,所有的类型都自动转换为 int 然后再做运算。 结果也是 int。 2:如果参与运算的操作数的类型是如下的类型中的:byte char short int ,而且一定包含 long 类型。所有的类型都自动转换为 long类型。然后再做运算。 结果也是 long。 3:如果参与运算的操作数的类型是如下的类型中的:byte char short int long,而且一定包含 float类型。所有的类型都自动转换为 float类型。然后再做运算。 结果也是 float。 4:如果参与运算的操作数的类型是如下的类型中的:byte char short int long float,而且一定包含 double类型。所有的类型都自动转换为 double类型。然后再做运算。 结果也是 double。 上述的转换都是 编译器 来完成的。自动完成的。在编译期完成类型的转换,也就是将小类型的数据 当作大类型的数据来使用(如果需要)。 注意:第一种 和 第二种 自动转换 是 绝对安全的。 三四种 有可能存在精度的损失。java 允许这么做。
2.赋值时的转换
规则:
小类型:表示的数值的范围比较小的。
大类型:表示的数值的范围比较大的。
可以直接把一个小类型的数据 赋值 给一个 大类型的变量。
引用数据类型的转换:
老虎当动物用。 自动转换。
3.类型自动转换图
4.强制类型转换
强制类型转换。 如果有将大类型的数据当作小类型的数据来使用的时候,就需要强制类型的转换。 大类型--强制-->小类型 不安全的。 语法: (强制转换为的类型)(被转换的数据); int x = 2; byte b1 = (byte)(x+1); b1 = (byte)x; 强制转换的规则: //强制类型转换 public class PowerChangeTypeTest{ public static void main(String[] args){ //整数之间的强制转换: //只保留 低n位的二进制,直接将多余的高位砍掉。不考虑符号位。只保留低位的数值位。 int i1 = 254; System.out.println(Integer.toBinaryString(i1)); byte b1 = (byte)(i1+1); System.out.println(b1);//-1 //浮点数向整数的强制转换: //1:没有超过整数的范围,那么直接去掉小数点部分。 //2:如果被转换的数据超过了整数的最大值,那么结果为最接近该浮点数的整数 System.out.println((int)1.1);//1 System.out.println((int)1.1E20);//2147483647 //double 强制转换为 float //1 : 没有超过被强转的类型,那么小数部分直接被截断。 //2 : 超过了被强转的类型。结果为 Infinity System.out.println((float)1.111111111111111111111111111111111111);//1.111112 System.out.println((float)1.1E100);//Infinity 无穷大 b1 = 127; b1 ++; System.out.println(b1);//-128 可以认为隐含了一个强制类型转换,转换的类型为 b1的类型。 //b1 = b1 + 1; b1 = 127; b1 += 1;//隐含了一个强制类型转换,强制转换的类型为 左边变量的类型。 System.out.println(b1);//-128 } }
5.字符串连接时的转换
System.out.println(""+a+b+c);
同样,字符串连接的时候,也只能是 字符串和 字符串之间做连接。
字符串可以和其他的任何类型做连接:
底层使实现:其他所有的类型,都要被转换为字符串之后在做连接。
6.练习
//得到一个随机字符[A-Z]or[a-z] (大小写也要随机),并打印. import java.util.Random; public class RandomCharTest{ public static void main(String[] args){ final int MAX = 'Z'+1; final int MIN = 'A'; //得到随机的大写字符 char ranChar = (char)(Math.random()*(MAX-MIN)+MIN); System.out.println("随机的大写字符:" + ranChar); Random random = new Random(); //大小写的随机 boolean isUpperCase = random.nextBoolean(); ranChar = isUpperCase ? ranChar : (char)(ranChar + 32); System.out.println("得到的随机字符为:" + ranChar); } }
六、分支选择
1.java流程控制
java 的代码的执行的路径的选择的种类。 1:顺序执行。 从上到下依次执行 2:分支选择: 根据条件来选择执行某些代码,跳过某些代码。 3:循环: 反复的执行某些代码。
2.if
if 语句: 单分支 选择。 if 是java 的关键字。 if 语句 的 语法: if(条件){ //if 代码块 } // 解释: 条件:必须是一个 boolean 表达式。返回值为 boolean 值的表达式。 if 代码块:一个使用{} 封闭的代码块。里面的内容可以是java 支持的任意行数的代码。 执行过程: 1:首先计算条件 的返回值。如果是 返回值 为 true。那么执行 if 代码块中所有的内容。 2:如果条件的返回值 为 false。那么就跳过所有的 if 代码块中的内容。 注意: 1:如果if 代码块中的内容为一行 代码,那么大括号可以省略。建议添加大括号,即使是一条java 代码。 2:不要在 条件小括号后 添加 分号。一个单独的分号是一条完整的java 语句。空语句。
3.if-练习
//求两个随机数的最大值 范围[0-20]. //需求:产生一个随机数,范围[0-20]. 来代表一个年龄 age, //使用if 语句,如果 age [0-3] 输出 还没有上学 [4-6] 幼儿园小朋友 [7-12] 小学生 [13-15] 中学生 [16-18] 高中生 [19-22] 大学生。 public class IfTest{ public static void main(String[] args){ final int MAX = 21, MIN = 0; //求两个随机数 int num0 = (int)(Math.random()*(MAX-MIN)+MIN); int num1 = (int)(Math.random()*(MAX-MIN)+MIN); System.out.println("两个随机数为:"+num0 + "\t\t"+num1); int max = num1; if(num0 > num1){ max = num0; } System.out.println("max = "+max); // if(num1 >= num0){ // max = num1; // } //产生一个随机的年龄 int age = (int)(Math.random()*(MAX-MIN)+MIN); System.out.println("age = "+age); if(age >=0 && age <=3){ System.out.println("还没有上学!"); } if(age >=4 && age <=6){ System.out.println("幼儿园小朋友!"); } if(age >=13 && age <=15){ System.out.println("初中生!"); } if(age >=7 && age <=12){ System.out.println("小学生!"); } if(age >=16 && age <=18){ System.out.println("高中生!"); } if(age >=19 && age <=22){ System.out.println("大学生!!"); } } }