JavaSE

一、Java简介

Java 是由 Sun Microsystems 公司于 1995 年 5 月推出的 Java 面向对象程序设计语言和 Java 平台的总称。由 James Gosling和同事们共同研发，并在 1995 年正式推出。
后来 Sun 公司被 Oracle （甲骨文）公司收购，Java 也随之成为 Oracle 公司的产品。

Java分为三个体系：

JavaSE（J2SE）（Java2 Platform Standard Edition，java平台标准版）
JavaEE(J2EE)(Java 2 Platform,Enterprise Edition，java平台企业版)
JavaME(J2ME)(Java 2 Platform Micro Edition，java平台微型版)。

2005 年 6 月，JavaOne 大会召开，SUN 公司公开 Java SE 6。此时，Java 的各种版本已经更名，以取消其中的数字 "2"：J2EE 更名为 Java EE，J2SE 更名为Java SE，J2ME 更名为 Java ME。

主要特性

Java 语言是简单的：

Java 语言的语法与 C 语言和 C++ 语言很接近，使得大多数程序员很容易学习和使用。另一方面，Java 丢弃了 C++ 中很少使用的、很难理解的、令人迷惑的那些特性，如操作符重载、多继承、自动的强制类型转换。特别地，Java 语言不使用指针，而是引用。并提供了自动分配和回收内存空间，使得程序员不必为内存管理而担忧。
Java 语言是面向对象的：

Java 语言提供类、接口和继承等面向对象的特性，为了简单起见，只支持类之间的单继承，但支持接口之间的多继承，并支持类与接口之间的实现机制（关键字为 implements）。Java 语言全面支持动态绑定，而 C++语言只对虚函数使用动态绑定。总之，Java语言是一个纯的面向对象程序设计语言。
Java语言是分布式的：

Java 语言支持 Internet 应用的开发，在基本的 Java 应用编程接口中有一个网络应用编程接口（java net），它提供了用于网络应用编程的类库，包括 URL、URLConnection、Socket、ServerSocket 等。Java 的 RMI（远程方法激活）机制也是开发分布式应用的重要手段。
Java 语言是健壮的：

Java 的强类型机制、异常处理、垃圾的自动收集等是 Java 程序健壮性的重要保证。对指针的丢弃是 Java 的明智选择。Java 的安全检查机制使得 Java 更具健壮性。
Java语言是安全的：

Java通常被用在网络环境中，为此，Java 提供了一个安全机制以防恶意代码的攻击。除了Java 语言具有的许多安全特性以外，Java 对通过网络下载的类具有一个安全防范机制（类 ClassLoader），如分配不同的名字空间以防替代本地的同名类、字节代码检查，并提供安全管理机制（类 SecurityManager）让 Java 应用设置安全哨兵。
Java 语言是体系结构中立的：

Java 程序（后缀为 java 的文件）在 Java 平台上被编译为体系结构中立的字节码格式（后缀为 class 的文件），然后可以在实现这个 Java 平台的任何系统中运行。这种途径适合于异构的网络环境和软件的分发。
Java 语言是可移植的：

这种可移植性来源于体系结构中立性，另外，Java 还严格规定了各个基本数据类型的长度。Java 系统本身也具有很强的可移植性，Java 编译器是用 Java 实现的，Java 的运行环境是用 ANSI C 实现的。
Java 语言是解释型的：

如前所述，Java 程序在 Java 平台上被编译为字节码格式，然后可以在实现这个 Java 平台的任何系统中运行。在运行时，Java 平台中的 Java 解释器对这些字节码进行解释执行，执行过程中需要的类在联接阶段被载入到运行环境中。
Java 是高性能的：

与那些解释型的高级脚本语言相比，Java 的确是高性能的。事实上，Java 的运行速度随着 JIT(Just-In-Time）编译器技术的发展越来越接近于 C++。
Java 语言是多线程的：

在 Java 语言中，线程是一种特殊的对象，它必须由 Thread 类或其子（孙）类来创建。通常有两种方法来创建线程：其一，使用型构为 Thread(Runnable) 的构造子类将一个实现了 Runnable 接口的对象包装成一个线程，其二，从 Thread 类派生出子类并重写 run 方法，使用该子类创建的对象即为线程。值得注意的是 Thread 类已经实现了 Runnable 接口，因此，任何一个线程均有它的 run 方法，而 run 方法中包含了线程所要运行的代码。线程的活动由一组方法来控制。Java 语言支持多个线程的同时执行，并提供多线程之间的同步机制（关键字为 synchronized）。
Java 语言是动态的：

Java 语言的设计目标之一是适应于动态变化的环境。Java 程序需要的类能够动态地被载入到运行环境，也可以通过网络来载入所需要的类。这也有利于软件的升级。另外，Java 中的类有一个运行时刻的表示，能进行运行时刻的类型检查。

发展历史

1995 年 5 月 23 日，Java 语言诞生
1996 年 1 月，第一个 JDK-JDK1.0 诞生
1996 年 4 月，10 个最主要的操作系统供应商申明将在其产品中嵌入 JAVA 技术
1996 年 9 月，约 8.3 万个网页应用了 JAVA 技术来制作
1997 年 2 月 18 日，JDK1.1 发布
1997 年 4 月 2 日，JavaOne 会议召开，参与者逾一万人，创当时全球同类会议规模之纪录
1997 年 9 月，JavaDeveloperConnection 社区成员超过十万
1998 年 2 月，JDK1.1 被下载超过 2,000,000次
1998 年 12 月 8 日，JAVA2 企业平台 J2EE 发布
1999 年 6月，SUN 公司发布 Java 的三个版本：标准版（JavaSE, 以前是 J2SE）、企业版（JavaEE 以前是 J2EE）和微型版（JavaME，以前是 J2ME）
2000 年 5 月 8 日，JDK1.3 发布
2000 年 5 月 29 日，JDK1.4 发布
2001 年 6 月 5 日，NOKIA 宣布，到 2003 年将出售 1 亿部支持 Java 的手机
2001 年 9 月 24 日，J2EE1.3 发布
2002 年 2 月 26 日，J2SE1.4 发布，自此 Java 的计算能力有了大幅提升
2004 年 9 月 30 日 18:00PM，J2SE1.5 发布，成为 Java 语言发展史上的又一里程碑。为了表示该版本的重要性，J2SE1.5 更名为 Java SE 5.0
2005 年 6 月，JavaOne 大会召开，SUN 公司公开 Java SE 6。此时，Java 的各种版本已经更名，以取消其中的数字 "2"：J2EE 更名为 Java EE，J2SE 更名为 Java SE，J2ME 更名为 Java ME
2006 年 12 月，SUN 公司发布 JRE6.0
2009 年 04 月 20 日，甲骨文 74 亿美元收购 Sun，取得 Java 的版权。
2010 年 11 月，由于甲骨文对于 Java 社区的不友善，因此 Apache 扬言将退出 JCP。
2011 年 7 月 28 日，甲骨文发布 Java7.0 的正式版。
2014 年 3 月 18 日，Oracle 公司发表 Java SE 8。
2017 年 9 月 21 日，Oracle 公司发表 Java SE 9
2018 年 3 月 21 日，Oracle 公司发表 Java SE 10
2018 年 9 月 25 日，Java SE 11 发布
2019 年 3 月 20 日，Java SE 12 发布

Java 开发工具

Java 语言尽量保证系统内存在 1G 以上，其他工具如下所示：

Linux 系统、Mac OS 系统、Windows 95/98/2000/XP，WIN 7/8系统。
Java JDK 7、8……
vscode 编辑器或者其他编辑器。
IDE：Eclipse、 IntelliJ IDEA、NetBeans 等。

安装好以上的工具后，我们就可以输出Java的第一个程序 "Hello World！"

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

Java开发环境配置

请参考菜鸟教程开发环境配置

二、Java语言基础

一、标识符

1、什么是标识符

在java源程序当中凡是程序员有权利自己命名的单词都是标识符

2、标识符的命名规则

一个合法的标识符只能由数字、字母、下划线_、美元符号$组成，不能含有其他符号
不能以数字开头
严格区分大小写
关键字不能做标识符
理论上无长度限制，但最好不要太长

3、标识符的命名规范

最好见名知意，如下示例：

public class UserService{//UserService用户服务类
	public void login(String username,String password){
			
	}
}
/*
遵守驼峰命名方式：
      UserService
      SystemService
      - 类名、接口名：首字母大写，后面每个单词首字母大写
      - 变量名、方法名：首字母小写，后面每个单词首字母大写
      - 常量名：全部大写
*/
public class UserService01{  //UserService01是一个类名，名字可以修改
	//main是一个方法名
	public static void main(String[] args){   //args是一个变量名   
		
	}
	//doSome就是方法名
	public static void doSome(){   
		int i = 10;  //i就是变量名
	}
}

4、合法和不合法的标识符

合法         不合法
----------------------
_123Test     123Test
class1       class
ABC$         HelloWorld!

二、关键字

请参考菜鸟教程关键字

三、关于字面值

/*
 字面值：字面值就是数据
	10、100
	3.14
	"abc"
	'a'
	true、false
	字面值是java源程序的组成部分之一。包括标识符和关键字它们都是java源程序的组成部分
	数据在现实世界当中是分门别类的，所以数据在计算机编程语言当中也是有类型的【数据类型】
		10、100                 属于整数型字面值
		3.14			属于浮点型字面值
		"abc"			属于字符串型字面值
		'a'			属于字符型字面值
		true、false		属于布尔型字面值
	注意：
		java语言当中所有的字符串型字面值必须使用双引号括起来
		java语言当中所有的字符型字面值必须使用单引号括起来
*/
public class Test01{
	public static void main(String[] args) {
		System.out.println(10);	
		System.out.println("abc");
		System.out.println("你怎么样？");
		System.out.println(false);
		System.out.println(true);
		System.out.println('A');
		System.out.println(3.14);
		System.out.println("3.14");
		//System.out.println('ABC');编译报错，因为单引号只能存放单个字符，属于字符型字面值
	}
}

四、变量

/*
        1.什么是变量？
		变量本质上来说是内存中的一块空间，这块空间有数据类型、有名字、有字面值
		变量包含三部分：数据类型、名称、字面值【数据】
		变量内存中存储数据的最基本的单元
        2.Java 中主要有如下几种类型的变量
          局部变量
          类变量（静态变量）
          成员变量（非静态变量）
	3.数据类型的作用？
		不同的数据有不同的类型，不同的数据类型底层会分配不同大小的空间
		数据类型是指导程序在运行阶段应该分配多大的内存空间
	4.变量要求：变量中存储的具体的数据必须和变量的数据类型一致，当不一致时会编译报错
	5.声明/定义变量的语法格式：
		数据类型 变量名;
			
		例如：
			int i;
	6.变量声明之后怎么赋值？
	  语法格式：
		变量名 = 字面值;
	  要求：字面值的数据类型必须和变量的数据类型一致
	  = 等号是一个运算符，叫做赋值运算符，赋值运算符先运算等号右边的表达式，表达式执行结束之后的结果赋值给左边的变量
	7.声明和赋值可以放到一起完成
		int i = 10;
	8.变量赋值之后，可以重新赋值，变量的值可以变化
		int i = 10;
		System.out.println(i);//10
		i = 20;
		System.out.println(i);//20
		i = 100;
		System.out.println(i);//100
	9.有了变量的概念之后，内存空间得到了重复的使用
		int i = 10;
		System.out.println(i);
		...
		....
		System.out.println(i);
	10.通常访问一个变量包括两种访问形式：
		第一种：读取变量中保存的具体数据 get/获取
		第二种：修改变量中保存的具体数据 set/设置
		i = 20;    //set
		System.out.println(i);  //get
	11.变量可以在一行上声明多个
		int a,b,c,d;
	12.java中的变量必须先声明，再赋值，才能访问
		int i; 程序执行到这里，内存空间并没有开辟出来，变量i并没有初始化所以没有赋值之前是无法访问的
*/
//例1
public class Test01{
	public static void main(String[] args) {
		//声明一个int类型的变量，起名为i
		int i;
		//System.out.println(i);
		//编译报错：变量i并没有初始化
		i = 100;//给i变量赋值，i变量在这里完成初始化，内存开辟
		System.out.println(i);	
		//i再次重新赋值
		i = 1000;
		System.out.println(i);
		//一行上可以同时声明多个变量
		int a,b,c = 300;  //a和b尚未初始化，c赋值300
		System.out.println(a);//编译错误
		System.out.println(b);//编译错误
		System.out.println(c);//300
		a = 0;
		b = 1;
		System.out.println(a);//0
		System.out.println(b);//1
	}
}
//例2
//关于java中的变量：
//1.在方法体当中的java代码，是遵循自上而下的顺序依次执行的。逐行执行
//2.在同一个作用域当中，变量名不能重名，但是变量可以重新赋值
public class Test02{
	public static void main(String[] args) {
		int i = 100;
		System.out.println(i);//100
		i = 200;
		System.out.println(i);//200
		//以下代码顺序有错误，先声明后赋值再访问
		/*
		System.out.println(k);
		int k = 200;
		*/

		/*
		int i = 90;
		System.out.println(i);
		*/
	}
}
//例3
/*关于java中的变量：
	变量的作用域
	1.什么是作用域
		变量的作用域其实描述的就是变量的有效范围
	3.变量的作用域只要记住一句话
		出了大括号就不认识了
*/

public class Test03{
	static int k = 40;//注意：这里的static不要去掉
	public static void main(String[] args) {
		//变量i的作用域是main方法，在整个main方法当中是有效的，可见的，可以访问的
		int i = 100;
		System.out.println(i);//可以
		System.out.println(k);//可以
		
		//以下会编写一个for循环语句,在for循环中讲解
		for(int a=0;a<10;a++){  //a变量的作用域是整个for循环，for循环结束之后，a变量的内存就释放了
		
		}
		//System.out.println(a);   //这里无法访问a变量
		
		int j;  //作用域是main方法
		for(j=0;j<10;j++){
		
		}
		System.out.println(j);  //访问的是main方法中的j变量

	}
	public static void doSome() {
		//这里无法访问main方法当中的变量i，已经出了i变量的作用域
		//System.out.println(i);
		System.out.println(k);//可以
	}
}
//例4
/*关于java中的变量：
	变量的分类：根据变量声明的位置来分类：
	局部变量：在方法体当中声明的变量叫做局部变量
	成员变量：在方法体外【类体之内】声明的变量叫做成员变量
	在不同的作用域当中，变量名可以重名，同作用域当中不能
	
*/
public class Test04{
	//成员变量
	int k = 200;
	//主方法：入口
	public static void main(String[] args) {
		//i变量就是局部变量
		int i = 3;
		System.out.println(i);  //java遵循 就近 原则
	}

	//成员变量
	int i = 100;  //声明变量
	//System.out.println(i);  //类体中不能直接编写java语句【除声明变量之外】
	
	//doSome方法
	public static void doSome() {
		//局部变量
		int i = 90;
		
	}
}

五、数据类型

/*
关于java中的数据类型
1.数据类型的作用是什么
	程序当中有很多数据，每一个数据都是有相关类型的，不同数据类型的数据占用空间大小不同。
	数据类型的作用是指导JVM在运行程序的时候给该数据分配多大的内存空间。
2.java中的数据类型包括两种：
	基本数据类型
	引用数据类型
3.关于基本数据类型：
	第一类：整数型
		byte,short,int,long
	第二类：浮点型
		float,double
	第三类：布尔型
		boolean
	第四类：字符型
		char
4.字符串“abc”不属于基本数据类型，属于 引用数据类型，字符属于基本数据类型
5.八种基本数据类型各自占用空间大小是多少
	基本数据类型         占用空间大小【单位：字节】     取值范围           默认值
	------------------------------------------------------------------------------
	byte                 1                              -128 ~ 127         0
	short                2                              -32768 ~ 32767     0 
	int                  4                                                 0
	long                 8                                                 0
	float                4                                                 0.0
	double               8                                                 0.0
	boolean              1                              true/false         false
	char                 2                              0 ~ 65535          \u0000
6.计算机在任何情况下都只能识别二进制。例如：101010
【现代的计算机底层采用交流电的方式，接通和断开，只识别0或1】
7.什么是二进制
	数据的一种表示形式。十进制表示满十进一原则。二进制表示满二进一原则
8.字节【byte】
	1 Byte = 8 bit 【1个字节 = 8个比特位】1个比特位表示一个二进制位：0/1
	1 KB   = 1024 Byte
	1 MB   = 1024 KB
	.....

9.整数型当中的byte类型，占用1个字节，所以byte类型的数据占用8个比特位。那么byte类型的取值范围是什么？
	关于java中的数字类型，数字都有正负之分的，所以在数字的二进制当中有一个二进制位被称为“符号位”。并且
	这个“符号位”在所有二进制位的最左边，0表示整数，1表示负数
	byte类型最大值：01111111
		2的7次方-1，结果是：127
	byte类型最小值：-128
	byte类型取值范围：[-128 ~ 127]
	byte类型可以表示256个不同的数字【256个不同的二进制】
10.二进制和十进制之间的转换规则：
	二进制转换十进制
	十进制转换二进制


*/


/*
数据类型之：char类型

*/
public class Test01{
	public static void main(String[] args){
		char c = 'a';
		System.out.println(c);

		char x = '国';
		System.out.println(x);
	}
}

/*
数据类型之char类型:转义字符 \
	转义字符出现在特殊字符之前，会将特殊字符转换成普通字符
	\n  换行符
	\t  制表符
	\'	普通的单引号
	\\	普通的反斜杠
	\"  普通的双引号

	
*/
public class Test02{
	public static void main(String[] args){
		//普通的a字符
		char c = 'a';
		System.out.println(c);
		
		//换行符，属于char类型的数据
		char x = '\n';
		//制表符tab，制表符和空格不同，他们的ASCII码不同
		char y = '\t';
		
		//例题：要求在控制台上输出反斜杠字符
		char k = '\\';
		System.out.println(k);
		//例题：要求在控制台上输出单引号字符
		char z = '\'';
		System.out.println(z);

	}
}

/*
数据类型之整数型
	java语言当中的整数型字面值被默认为int类型处理。要让这个整数型字面值被当作long类型来处理的话，
	需要在整数型字面值后面添加L
	java语言当中的整数型字面值有三种表示方式
		十进制【是一种缺省默认的方式】
		八进制【在编写八进制整数型字面值的时候需要以0开始】
		十六进制【在编写十六进制整数型字面值的时候需要以0x开始】


*/
public class Test03{
	public static void main(String[] args){
		int a = 10;
		int b = 010;
		int c = 0x10;

		System.out.println(a);//10
		System.out.println(b);//8
		System.out.println(c);//16
	}
}
public class Test04{
	public static void main(String[] args){
		long x = 100L;  //100L是long类型字面值，x是long类型变量，不存在类型转换，直接赋值
		//int y = x;  //x变量是long类型，8个字节，y变量是int类型，4个字节，所以会出现编译错误，因为大容量不能直接赋值给小容量
		
		/*
			大容量转换成小容量，需要进行强制类型转换
			强制类型转换需要加强制类型转换符
			加上强制类型转换符之后编译通过了，但是运行阶段可能损失精度
			所以强制类型转换谨慎使用，因为损失精度之后可能损失很严重
			强转原理：
			原始数据：00000000 00000000 00000000 00000000 00000000 00000000 00000000 01100100
			强转之后的数据：00000000 00000000 00000000 01100100
			将左边的二进制砍掉【所有的数据强转的时候都是这样完成的】
		*/
		int y = (int)x;
		System.out.println(y);

		//在java语言当中，当一个整数型字面值没有超出byte类型取值范围的话，该字面值可以直接赋值给byte类型的变量

		byte b = 50;//true
		byte c = 127;//true
		byte d = 128;//false

	}
}

/*
	关于浮点型数据类型：
	float 单精度【4个字节】
	double 双精度【8个字节，精度较高】
	在java语言当中，所有的浮点型字面值默认被当作double类型来处理，
	要想该字面值当作float类型来处理，需要在字面值后面添加F/f
*/
public class Test01{
	public static void main(String[] args){
		//float f = (float)5.1;
		float f = 5.1f;
	}
}


/*
	关于布尔型数据类型：boolean【占1个字节】
	在java语言当中boolean类型只有两个值：true、false
	
*/
public class Test01{
	public static void main(String[] args){
		boolean login = true;
		if(login){
			System.out.println("登录成功");
		}else{
			System.out.println("登录失败");
		}
	}
}

/*
关于基本数据之间的互相转换：转换规则
	1.八种基本数据类型当中除布尔类型之外剩下的7种类型之间都可以互相转换
	2.小容量向大容量转换，称为自动类型转换，容量从小到大排序:
		byte < short < int < long < float < double
			char < 
			注：任何浮点类型不管占用多少个字符，都比整数型容量大
				char和short可表示的种类数量相同，但是char可以取更大的正整数
	3.大容量转换成小容量，叫做强制类型转换，需要加强制类型转换符，程序才能编译通过，但是在运行阶段可能会损失精度，所以谨慎使用
	4.当整数字面值没有超出byte，short，char的取值范围，可以直接赋值给byte，short，char类型的变量
	5.byte，short，char混合运算的时候，各自先转换成int类型再做运算
	6.多种数据类型混合运算，先转换成容量最大的那种类型再做运算
*/

六、运算符

运算符可以分为以下几种：

算术运算符
关系运算符
位运算符
逻辑运算符
赋值运算符
其他运算符

/*
	算术运算符
	+       求和
	-	相减
	*	乘积
	/	商
	%	求余数【取模】
	++	自加1
	--	自减1 
*/
public class Test01{
	public static void main(String[] args){
		int i = 10;
		int j = 3;
		System.out.println(i+j);//13
		System.out.println(i-j);//7
		System.out.println(i*j);//30
		System.out.println(i/j);//3
		System.out.println(i%j);//1
		int k = 10;
		k++;
		System.out.println(k);//11
		int y = 10;
		++y;
		System.out.println(y);//11
		//小结：++运算符可以出现在变量前，也可以出现在变量后，无论是变量前还是变量后，只要++运算结束，该变量中的一定会自加1
		//++ 出现在变量后
		//规则：先做赋值运算，再对变量中保存的值进行自加1
		int a = 100;
		int b = a ++;
		System.out.println(a);//101
		System.out.println(b);//100
		//++出现在变量前
		//规则：先进行自加1运算，再进行赋值操作
		int m = 20;
		int n = ++m;
		System.out.println(m);//21
		System.out.println(n);//21
		
		int e = 100;
		System.out.println(e++);//100
		System.out.println(e);//101

		int s = 100;
		System.out.println(++s);//101
		System.out.println(s);//101
	}
}

/*
关系运算符：
	>	大于
	>=	大于等于
	<	小于
	<=	小于等于
	==	等于
	!=	不等于
= 是赋值运算符，==是关系运算符
关系运算符的运算结果一定是布尔类型：true/false

关系运算符的运算原理：
	int a = 10;
	int b = 10;
	a > b 比较的时候，比较的是a中保存的10这个值和b中保存的10这个值之间的大小比较

*/
public class Test01{
	public static void main(String[] args){
		int a = 10;
		int b = 10;
		System.out.println(a>b);//false
		System.out.println(a>=b);//true
		System.out.println(a<b);//false
		System.out.println(a<=b);//true
		System.out.println(a==b);//true
		System.out.println(a!=b);//false
	}
}

/*
逻辑运算符
	&	逻辑与  （两边都是true，结果才是true）
	|	逻辑或  （两边只要有一个是true，结果就是true）
	！	逻辑非	（取反，！false就是true，！true就是false，是一个单目运算符）
	^	逻辑异或（两边只要不一样，结果就是true）
	&&	短路与   第一个表达式执行结果是false，会发生短路与。
	||	短路或	 第一个表达式执行结果是true，会发生短路或。

1.逻辑运算符要求两边的算子都是布尔类型，并且逻辑运算符最终的运算结果也是一个布尔类型
2.短路与和逻辑与最终的运算结果是相同的，只不过短路与存在短路现象
3.短路或和逻辑或最终的运算结果是相同的，只不过短路或存在短路现象
4.什么情况下发生短路现象呢？？？
5.什么时候选择使用逻辑与运算符？什么时候选择使用短路与运算符？

*/
public class Test
{
	public static void main(String[] args){
		System.out.println(true & true); //true
		System.out.println(true & false); //false
		System.out.println(true | false); //true
		System.out.println(false & false); //false
		System.out.println(!true); //false
		System.out.println(true ^ false); //true
		System.out.println(false ^ false); //false
		System.out.println(true ^ true); //false

		//逻辑与和短路与
		int x = 10;
		int y = 8;
		//逻辑与
		System.out.println(x < y & ++x < y);
		System.out.println(x);//11
		
		//短路与
		//a<s结果是false，整个表达式结果已经确定是false，所有后面的表达式不再执行，这种现象被称为短路现象
		//短路与才会有短路现象，逻辑与是不会存在短路现象的。短路与在开发中常用
		int a = 10;
		int s = 8;
		System.out.println(a < s && ++a < s);
		System.out.println(a);//10
	}
}

/*
赋值运算符：
	基本的赋值运算符
	=
	扩展的赋值运算符
	+=
	-=
	*=
	/=
	%=
	优先级：先执行等号右边的表达式，将执行结果赋值给左边的变量

	注意：
		byte i = 10;
		i += 5; 等同于i = (byte)(i + 5);

		int k = 10;
		k += 5; 等同于k = (int)(k + 5);

		long x = 10L;
		int y = 20;
		y += x; 等同于y = (int)(y + x);

	结论：扩展类的赋值运算符不改变运算结果类型，假设最初这个变量的类型是byte类型，
			无论怎么进行追加或追减，最终该变量的数据类型还是byte类型

字符串连接运算符
	1.java中的"+"运算符：有两个作用，一是求和，二是字符串的连接运算
	2.当"+"运算符两边的数据都是数字的话，一定是进行加法运算
	3.当"+"运算符两边的数据只要有一个数据是字符串，一定会进行字符串连接运算，并且连接运算之后的结果还是一个字符串类型
		数字 + 数字 ---> 数字【求和】
		数字 + "字符串" ---> "字符串"【字符串连接】
	4.在一个表达式当中可以出现多个"+"，在没有添加小括号的前提下，遵循自左向右的顺序依次运算

三目运算符
	语法：布尔表达式 ？ 表达式1 : 表达式2
	
*/
public class Test
{
	public static void main(String[] args){
		//基本的赋值运算符
		int i = 10;
		System.out.println(i);//10
		i = i + 5;
		System.out.println(i);//15
		
		//扩展的赋值运算符
		i += 5; //等同于i = i + 5【其实不等】
		System.out.println(i);//20
		//-------------------------------------
		//字符串连接运算符
		String userName = "A";
		System.out.println("欢迎你" + userName + "回来");
		//-------------------------------------
		//三目运算符
		String s = sex ? "男" : "女";
		System.out.println(s);
	}
}

七、条件语句

/*
if语句：
	1.语法结构：四种编写方式
		一：if(布尔表达式){
				java语句;
				....
			}
		二：if(布尔表达式){
				java语句;
				....
			}else{
				java语句;
				....
			}
		三：if(布尔表达式){
				java语句;
				....
			}else if(布尔表达式){
				java语句;
				....
			}
			...

		四：if(布尔表达式){
				java语句;
				....
			}else if(布尔表达式){
				java语句;
				....
			}else(布尔表达式){
				java语句;
				....
			}
	2.重点：对于java中的if语句来说，只要一个分支执行，整个if语句全部结束
	3.注意：以上的第二，第四种编写方式都带有else分支，这两种方式都可以100%保证会有分支执行
	4.所有控制语句都是可以嵌套使用的，只要合理嵌套就行
	5.if语句的分支中只有一条java语句的话，大括号可以省略不写【不推荐】
*/

public class Test
{
	public static void main(String[] args){
		//需求：所在位置的5公里范围之内有肯德基的话，去kfc吃午饭
		double distance = 1.0;
		if(distance < 5){
			System.out.println("去kfc吃饭");
		}
		/*需求：
			假设系统给定一个考生的成绩，成绩可能带有小数点，根据学生的成绩判断该学生的成绩等级：
				[90-100]	A
				[80-90]		B
				[70-80]		C
				[60-70]		D
				[0-60]		E
				用if语句应该怎么写？？？
		*/
		double score = 90;
		String grade = "成绩等级为E";
		if (score < 0 || score > 100){
			grade = "输入的成绩不合法";
		}else if (score >= 90){
			grade = "输入的成绩等级为A";
		}else if(score >= 80){
			grade = "输入的成绩等级为B";
		}else if(score >= 70){
			grade = "输入的成绩等级为C";
		}else if(score >= 60){
			grade = "输入的成绩等级为D";
		}
		System.out.println(grade);
		//---------------------------
		//接收用户键盘输入
		//第一步：创建键盘扫描器对象
		java.util.Scanner s = new java.util.Scanner(System.in);
		//第二步：调用Scanner对象的next()方法开始接收用户键盘输入
		String userInputContent = s.next();//接受文本【以字符串的形式接收】
		//int num = s.nextInt(); 接受数字【以整数型int的方式接收】
		System.out.println("你输入了:"+userInputContent);
		//System.out.println("你输入的数字是:"+num);
		
		//对上面的例子进行修改，使用键盘输入------------------
		java.util.Scanner s = new java.util.Scanner(System.in);
		System.out.print("请输入成绩：");
		int score = s.nextInt();
		String grade = "E等级";
		if(score < 0 || score > 100){
			grade = "你输入的成绩不合法";
		}else if (score >= 90){
			grade = "输入的成绩等级为A";
		}else if(score >= 80){
			grade = "输入的成绩等级为B";
		}else if(score >= 70){
			grade = "输入的成绩等级为C";
		}else if(score >= 60){
			grade = "输入的成绩等级为D";
		}
		System.out.println(grade);

	}
}

/*
switch语句
语法：
	switch(int或){
		case int或String类型的字面值或变量:
			java语句;
			...
		case int或String类型的字面值或变量:
			java语句;
			...
		...
		default :
			java语句;
			...
	}
执行原理：
	switch后面的小括号当中的数据和case后面的数据进行一一匹配，匹配成功的分支执行，按照自上而下的顺序依次匹配
	匹配成功的分支执行，分支当中最后有break语句的话，整个switch语句终止
	匹配成功的分支执行，分支中没有break语句的话，直接进入下一个分支执行，这种现象被称为case穿透现象
	所有分支都没有匹配成功，当有default的语句，会执行default分支当中的程序
	case可以合并：
		int i = 10;
		switch(i){
			case 1: case 2: case 3: case 10:
			System.out.println("Test");
		}
*/
public class Test
{
	public static void main(String[] args){
		//需求：接收用户的输入：1表示星期一，2表示星期二
		java.util.Scanner s = new java.util.Scanner(System.in);
		System.out.print("请输入数字:");
		int num = s.nextInt();
		switch(num){
			case 1:
				System.out.println("星期一");
				break;
			case 2:
				System.out.println("星期二");
				break;
			case 3:
				System.out.println("星期三");
				break;
			case 4:
				System.out.println("星期四");
				break;
			case 5:
				System.out.println("星期五");
				break;
			case 6:
				System.out.println("星期六");
				break;
			case 7:
				System.out.println("星期七");
				break;
			default :
				System.out.println("输入错误");
		}
		//case穿透把break去掉就行
		/*
		需求：
			使用switch判断考生成绩等级
			1、有效成绩范围[0-100]
			2、考生成绩可能带有小数
			90-100	A
			80-90	B
			70-80	C
			60-70	D
			0-60	E
		*/
		double score = 95.5;
		//转换成int
		int grade = (int)(score / 10);
		switch(grade) {
			case 9 : case 10 :
				System.out.println("A");
				break;
			case 8 :
				System.out.println("B");
				break;
			case 7 :
				System.out.println("C");
				break;
			case 6 :
				System.out.println("D");
				break;
			default :
				System.out.println("E");
		}
	}
}

八、循环结构

/*
for循环
	语法结构：
		for(初始化表达式 ; 布尔表达式 ; 更新表达式){
			//需要重复执行的代码片段
		}
	执行原理：
		1、初始化表达式 ，布尔表达式，更新表达式都不是必须的【分号必须】
		2、初始化表达式最先执行，并且在整个for循环当中只执行一次
		3、布尔表达式必须是true/false，不能是其他值

*/
public class Test
{
	public static void main(String[] args){
		//找出1-100的所有奇数
		//第一种方案
		for(int i = 1; i < 100; i += 2){
			System.out.println("奇数-->"+i);
		}
		//第二种方案
		for(int i = 1; i < 100; i ++){
			if(i % 2 != 0){
				System.out.println(i);
			}
		}
		//----------------------------
		//计算1-100奇数的和
		int sum = 0;
		for(int i = 1; i < 100; i += 2){
			sum += i;
		}
		System.out.println("sum="+sum);
		//-----------------------------
		//使用for循环输出九九乘法表
		for(int i = 1; i <= 9; i ++){//外层循环九次
			for(int j = 1; j <= i; j ++){
				System.out.print(i + "*" + j + "=" + i * j + " ");
			}
			System.out.println();//换行
		}
		//编写for循环找出1-100中所有的素数（能被1和它本身整除）
		for(int i = 2; i <= 100; i++){
			boolean isSuShu = true;//默认将i看作是一个素数【标记在开发中经常用】
			for(int j = 2; j < i; j++){
				if(i % j == 0){
					isSuShu = false;
					break;
				}
			}
			if(isSuShu){//是素数
				System.out.println(i);
			}	
		}
		
		//编写for循环找出1-100中所有的素数，要求每8个换一行输出
		int count = 0;
		for(int i = 2; i <= 100; i++){
			boolean isSuShu = true;
			for(int j = 2; j < i; j++){
				if(i % j == 0){
					isSuShu = false;
					break;
				}
			}
			if(isSuShu){
				System.out.println(i + " ");
				count++;
				if(count % 8 == 0){			
					System.out.println();
				}
				//可以改为
				/*if(count == 8){			
					System.out.println();
					count = 0;//归0
				}*/
			}		
		}
	}
}

/*
while循环：
	1、语法结构：
		while(布尔表达式){
			循环体;
		}
	2、循环次数：0-n次

*/
public class Test
{
	public static void main(String[] args){
		int i = 10;
		while(i > 0){
			System.out.println(i--);//10 9 8 7 6 5 4 3 2 1 
			System.out.println("--->"+i);//9 8 7 6 5 4 3 2 1 0
		}
		System.out.println("--->"+i);//0
		//-------------------------------------------
		int j = 10;
		while(j >= 0){
			System.out.println(--j);//9 8 7 6 5 4 3 2 1 0 -1
		}
		System.out.println("--->"+j);//-1

	}
}

/*
do..while循环
	语法结构：
		do{
			循环体;
		}while(布尔表达式);
	循环次数：1-n
*/
public class Test
{
	public static void main(String[] args){
		int i = 10;
		do{
			System.out.println(i);//1 2 3 4 5 6 7 8 9 10
			i++;
		}while(i <= 10);
	}
}


/*
break语句：
	1、break是java语言当中的关键字，被翻译为中断
	2、break + ; 可以成为一个单独完整的java语句：break;
	3、break语句使用在switch语句中，用来终止switch的语句执行
	4、break语句使用在循环中，用来终止循环的执行。for,while,do...while
	5、默认终止的循环是最近的语句
*/
public class Test
{
	public static void main(String[] args){
		for(int i = 0; i < 10; i++){
			if(i == 5){
				break;//终止当前的for循环
			}
			System.out.println("--->");//0 1 2 3 4
		}
	}
}

/*
continue语句：
	1、continue表示继续，下一个的意思
	2、continue也是一个关键字，主要出现在循环语句中。continue;
	3、break和continue的区别
		break表示循环不再执行，跳出循环，终止循环
		continue表示终止当前循环，直接进入下一次循环继续执行

*/
public class Test
{
	public static void main(String[] args){
		for(int i = 0; i < 10; i++){
			if(i == 5){
				continue;//停止本次循环，直接进入下一次循环继续执行
			}
			System.out.println("i="+i);//0 1 2 3 4   6 7 8 9
		}
	}
}

九、方法

1.什么是方法？

Java方法是语句的集合，它们在一起执行一个功能。

方法是解决一类问题的步骤的有序组合
方法包含于类或对象中
方法在程序中被创建，在其他地方被引用

2.方法的优点有哪些？

使程序变得更简短而清晰。
有利于程序维护。
可以提高程序开发的效率。
提高了代码的重用性。

3.方法的结构

/*
修饰符 返回值类型 方法名(参数类型 参数名){
    ...
    方法体
    ...
    return 返回值;
}
*/
//如：
public static int age(int birthday){...}

//示例：下面的方法包含 2 个参数 num1 和 num2，它返回这两个参数的最大值。 
public static int max(int num1, int num2) {
   int result;
   if (num1 > num2){
      result = num1;
   }else{
      result = num2;
   }
   return result; 
}
//简略写法如下------------------运用了三元运算符
public static int max(int num1, int num2) {
  return num1 > num2 ? num1 : num2;
}

4.方法的调用

Java 支持两种调用方法的方式，根据方法是否返回值来选择。

//示例：
public class TestMax {
   // 主方法
   public static void main(String[] args) {
      int i = 5;
      int j = 2;
      int k = max(i, j);//调用了max方法
      System.out.println( i + " 和 " + j + " 比较，最大值是：" + k);
   }
 
   // 返回两个整数变量较大的值 
   public static int max(int num1, int num2) {
      int result;
      if (num1 > num2){
         result = num1;
      }else{
         result = num2;
      }
      return result; 
   }
}

5.void关键字

首先void是空的意思，它表示在方法声明的时候表示该方法没有返回值（但是可以用 return; 来退出该方法）

//示例：
public class Test{
      public static void main(String[] args){
           int i = 5;
           int j = 2;
           int k = max(i, j);//调用了max方法
           sum(1,3);////调用了sum方法
           System.out.println( i + " 和 " + j + " 比较，最大值是：" + k); 
      }
      public static void sum(int a, int b){
            System.out.println(a + "+" + b + "=" + (a + b));//也可以写成return;结束该方法没有返回值
      }
      public static int max(int num1, int num2){
            int result;
            if (num1 > num2){
                  result = num1;
            }else{
                  result = num2;
            }
            return result; //结束方法，有返回值
      }
}

6.方法重载【overload】

/*
	1、生么时候用方法重载？
           功能相似时用方法重载
	2、满足方法重载的条件：
	   -在同一个类中
	   -方法名相同
	   -参数列表不同：
			数量不同
			顺序不同
			类型不同
	
*/
//例
public class Test
{
	public static void main(String[] args){
		m1();
		m1(10);

		m2(2,3.0);
		m2(3.0,2);

		m3(2);
		m3(2.0);

	}
	//数量不同
	public static void m1(){
		
	}
	public static void m1(int a){
	
	}
	//顺序不同
	public static void m2(int a,double b){
		
	}
	public static void m2(double a,int b){
	
	}
	//类型不同
	public static void m3(int x){
		
	}
	public static void m3(double x){
	
	}
}
/*
方法递归
	1、什么是递归：方法自身调用自身
		a(){
			a();
		}
	2、递归是很耗费内存的，不需要时尽量不用
	3、递归必须有结束条件，否则会发生栈内存溢出错误
*/
//例
public class Test
{
	public static void main(String[] args){
		System.out.println("main begin");
		doSome();
		System.out.println("main over");
	}
	public static void doSome(){
		System.out.println("doSome begin");
		doSome();
		System.out.println("doSome over");
	}
}

//不使用递归计算1-N的和[可以不使用递归就不用]
public class Test01
{
	public static void main(String[] args){
		/*普通方法
		int n = 4;
		int sum = 0;
		for(int i = 0; i <= 4; i++){
			sum += i;
		}
		System.out.println("sum="+sum);
		*/

		int n = 4;
		int retValue = sum(n);
		System.out.println(retValue);
	}
	//单独定义一个方法，这是一个独立的功能，可以完成1-N的求和
	public static int sum(int n){
		int result = 0;
		for(int i = 0; i <= n; i++){
			result += i;
		}
		return result;
	}
}

//使用递归计算1-N的和
public class Test02
{
	public static void main(String[] args){
		//1-4的和
		int n = 4;
		int retValue = sum(n);
		System.out.println(retValue);
	}
	public static int sum(int n){
		if(n == 1){
			return 1;
		}
		return n + sum(n - 1);
	}
}

//不使用递归计算N的阶乘
public class Test03
{
	public static void main(String[] args){
		//5的阶乘
		int n = 5;
		int retValue = method(n);
		System.out.println(retValue);
	}
	public static int method(int n){
		int result = 1;
		for(int i = n; i > 0; i--){
			result *= i;
		}
		return result;
	}
}

//使用递归计算N的阶乘
public class Test04
{
	public static void main(String[] args){
		//5的阶乘
		int n = 5;
		int retValue = method(n);
		System.out.println(retValue);
	}
	public static int method(int n){
		if(n == 1){
			return 1;
		}
		return n * method(n - 1);
	}
}

posted @ 2020-11-17 22:14 请叫我先生、阅读(94) 评论(0) 收藏举报

刷新页面返回顶部

远望自己

假如你下午四点钟来，那么从三点钟起我就开始感到高兴。