第一章 Java基础学习整理（从小白到简单的程序编写）

1 什么是Java

Java语言是一种可以撰写跨平台应用软件的面向对象的程序设计语言，由当时任职sun公司的James Gosling等人于1990年代初开发，它最初被命名为Oak。Java伴随着互联网的迅猛发展而发展，逐渐成为重要的网络编程语言。

Java是一种面向对象的语言。

Java是一种与平台无关的语言，提供了程序运行的解释环境。可跨平台运行。

Java是一种健壮的语言，吸收了C++语言的优点，去掉了影响程序健壮性的部分，增加了新的语言特点。

2 Java常用知识

2.1Java的三个体系

Java SE（Java Platform，Standard Edition）。Java SE 以前称为 J2SE。它允许开发和部署在桌面、服务器、嵌入式环境和实时环境中使用的 Java 应用程序。Java SE 包含了支持 Java Web 服务开发的类，并为 Java Platform，Enterprise Edition（Java EE）提供基础。

Java EE（Java Platform，Enterprise Edition）。这个版本以前称为 J2EE。企业版本帮助开发和部署可移植、健壮、可伸缩且安全的服务器端 Java 应用程序。Java EE 是在 Java SE 的基础上构建的，它提供 Web 服务、组件模型、管理和通信 API，可以用来实现企业级的面向服务体系结构（service-oriented architecture，SOA）和 Web 2.0 应用程序。

Java ME（Java Platform，Micro Edition）。这个版本以前称为 J2ME。Java ME 为在移动设备和嵌入式设备（比如手机、PDA、电视机顶盒和打印机）上运行的应用程序提供一个健壮且灵活的环境。Java ME 包括灵活的用户界面、健壮的安全模型、许多内置的网络协议以及对可以动态下载的连网和离线应用程序的丰富支持。基于 Java ME 规范的应用程序只需编写一次，就可以用于许多设备，而且可以利用每个设备的本机功能。

2.2Java的构成

Java运行环境的组成，从核心到外围包括 JIT、JVM、JRE、JDK。

JDK(Java Develop ToolKit):它里面有很多Java所编写的开发工具(如:javac.exe、jar.exe),还包括了一个jre的调试环境。

JRE(Java Runtime Environment):是Java运行的基础，它提供了Java运行的API,Java程序必须有JRE才能正常运行。

JVM(Java Vitual Machine):它是Java运行的虚拟机环境。

JIT(Java In Time):即Java即时编译器，是JVM的一部分，属于内核部分。

3 配置环境（保姆级教学）

3.1 JDK下载及安装

1.JDK下载地址：https://www.oracle.com/java/technologies/javase-downloads.html

进去后选择适合自己电脑系统的版本进行下载

下载后会得到一个安装包

打开后

点击下一步

默认安装在C盘下，也可自定义安装位置，（安装位置需要记住，一会环境变量配置用到）点击下一步开始安装

安装过程不会很长，安装完毕后弹出窗口，关闭即可。

3.2JDK环境配置

JDK安装完成之后就是环境变量的配置了，JDK11以后里包含JRE，所以不可以不用单独再配置JRE，甚至变量名JAVA_HOME也可以不用配置（更新版本时需要将完整路径更换），具体做法如下：
右键点击我的电脑->属性->高级系统设置->环境变量
win10:直接双击path变量名（path变量非常重要，不要删除自己不确定或不认识的东西）

点击新建

在新建框中输入JDK的bin目录路径，就可以正常使用了

wi7:双击path变量后，直接在后边添加JDK的bin目录路径就可以了
（其他教程配置JAVA_HOME变量内容为JDK安装路径，在classpath变量中设置jdk的lib路径，但是我实践证明只配置path变量就能正常使用，有知道两者区别的大佬欢迎指正）

3.3 eclipse下载及安装

配置好环境变量后就可以进行Java程序的编写与运行了，但是为了开发方便，还需要安装开发工具。
登录eclipse官网，点击下载（Download），官网就会准备好适合此电脑的最新版本以供下载。


确认下载(请忽略有些许潦草的笔迹)，点击后会开始下载并弹出向eclipse社区捐款页面，不捐款也在正常下载（看个人意愿）

下载完毕后打开下载到的安装包
点击第一个选项(适用于Java的开发工具)

选择安装位置然后确定安装即可

如果刚接触Java非常不推荐使用eclipse汉化版，有汉化版允许的部分变量名、类名、方法名的命名方式和英文版不兼容，刚开始接触Java就用汉化版会养成很多不太好的习惯。

4 hello world与Java工作原理

至此可以正式写出Java的第一条程序：hello world！ //多少懵懂少年的第一次都给了它
具体操作步骤为：
先创建一个Java项目，并命名
File->New->Java Project


右键点击新建的项目，选择new->class创建一个类

完成后出现这个就代表着可以进行程序编辑与运行了

程序如下

package Test;

public class Dome1 {
	public static void main(String[] args) {
        System.out.println("hello world!");//这一句是输出语句，作用是将括号内的结果输出到控制台
	}

}

点击运行图标

控制台出现hello world!结果
Java工作流程：

1. 根据需求编写Java程序
2. 保存编写好的Java源文件 以.Java后缀
3. 经过编译器，生成.lass后缀的字节文件
4. 由解释器解释字节文件生成结果

5 命名规范及注释、标识符

1.代码中的命名均不能以下划线或美元符号开始，也不能以下划线或美元符号结束。
2.方法名、参数名、成员变量、局部变量都统一使用 lowerCamelCase 风格，必须遵从
驼峰形式。
3.代码中的命名严禁使用拼音与英文混合的方式，更不允许直接使用中文的方式。
说明：正确的英文拼写和语法可以让阅读者易于理解，避免歧义。注意，即使纯拼音命名方式
也要避免采用。
具体推荐参考阿里巴巴Java开发手册
前期一个养成良好的编程习惯非常重要，不仅方便别人阅读，更是为了让自己隔一段时间再回过头来看自己写的代码时不至于崩溃。。。。。

6 数据类型

1.基本数据类型

Java所有的数值类型变量可以互相转换。

整数类型：数字的默认类型为int型，所有类型赋值时范围不能超过该类型的最大值。

浮点型：默认类型为双精度类型：double,需要设置单精度类型时加后缀f或F。

范围速查表

    基本类型：short 
    范围：-32768——32767
    
    基本类型：byte 
    范围：-128——127        

    基本类型：int 
   范围：-2147483648——2147483647
    
    基本类型：long 
    范围：-9223372036854775808——9223372036854775807
    
    基本类型：float 
    范围：1.4E-45——3.4028235E38
    
    基本类型：double
    范围：4.9E-324——1.7976931348623157E308

类型转换方式：

1. 自动类型转换：范围小的变量类型赋值给范围大的类型时会自动转换，例如:int a = 1; double b = a;此时b的值为1.0，类型为double型
2. 强制类型转换：范围大的变量类型赋值给范围小的变量类型时，可能会导致部分数值丢失 ，需要用到强制转换，例如：
   double b = 1.22; int a = (int) b;将b赋值给int类型的a时，需要先将b强制转换成int类型（b前加**(int)**），再进行赋值，此时a的值为1；后面的0.22直接被”砍掉“（不遵循四舍五入）。

2.引用数据类型

• 类类型数据（例如：字符串：String类型）
• 接口类型
• 数组类型

7 变量、常量定义及初始化

变量

1.变量的定义：变量是计算机内存中的一个存储区域，想要创建一个变量，必须要声明变量的类型（存哪种类型的数据）和变量名。声明好一个变量后需要初始化（赋一个初始值）才能参与运算、输出等。
2.变量声明格式：数据类型 变量名 = 初始化值
例如：整数类型变量int a1 = 1; long a2 = 1; char a3 = 'a'; String a4 = "hello"; int [] = {1,2,3};等

8 运算符及优先级

在一段计算式中，优先级高的运算符优先参与运算，例如加减乘除混合运算中乘除优先级高，所以先算乘除。只有乘除时，乘和除优先级相等，所以从左到右依次计算。
Java中也是同样遵循优先级高的运算符先进行运算，Java中的运算符分为以下几种：

1. 算数运算符
   +（加）、- （减）、* （乘）、/（除）、%（取模，取左除右的余数）、++（自增，给结果加一,i++ 相当于 i = i + 1;）、- -（自减，给结果减一,i–相当于i = i - 1;）

int i  = 3;
int  k = 2;
int s = 0;
 s =  i + k  *  i  / k; //s的结果为6
 s = i % k;             //s的结果为1,%用于取余
 s = ++i + --i;         //s的结果为7，++i执行3+1，此时i为4，--i执行4-1结果为3

还有一个小重点，++i与i++的区别
前置型自增（++a）:++在前，计算前就增加一
后置型自增（a++）:++在后，计算后再加一

int a1 = 0;
int a2 = 0;
a2 = a1++ + a1++;
System.out.println(a1+","+a2);//结果为2，1  

int a1 = 0;
int a2 = 0;
a2 = ++a1 + ++a1;
System.out.println(a1+","+a2);//结果为2，3

int a1 = 0;
int a2 = 0;
a2 = ++a1 + a1--;
System.out.println(a1+","+a2);//结果为0，2

2. 关系运算符（多用于布尔类型表达式）
   关系运算符表示两数之间关系，结果有真（true）和假(false)两种(也就是成立和不成立)。
   关系运算符有：==（等于）、！=（不等于）、>（大于）、<（小于）、>=（大于等于）、<=（小于等于）。

int a = 0;
int b = 1;
System.out.println(a1==a2);//结果为false，

3. 逻辑运算符
   分为三种：&&（与）、||（或）、！（非）
   a && b：表示a与b双方都为真时，整体才为真
   a || b ：表示a或b有一个为真，则整体为真
   ！a ：表示只要不是a，则就是真

int a = 0;
int b = 1;
int c = 1;
System.out.println(a==b && b==c);//结果为false
System.out.println(a==b || b==c);//结果为true

4. 赋值运算符
   赋值运算符最常用的就是=：表示将右边的数值替换到左边

int a = 1;
int b = 2;
a = b;
System.out.println(a);//结果为2

其他常见的还有+=：a+=b等价与a = a + b
以及 - =、*=、/=、(%)=等同理。

5. 条件运算符( ?: )

条件运算符也叫三元运算符，举例：a > b ? x:y
如果 a>b为真，则执行x,如果为假 则执行y

运算符的优先级
优先级由高到底表示为下表中具有最高优先级的运算符在的表的最上面

留个作业 😃

		int a = 1;
		int b = 1;
		int c = 0;
		boolean bo = a++ + b++ == ++b;
		c = bo ? ++a:b++;
		System.out.println("a:"+a+"    b:"+b+"    bo:"+bo+"    c:"+c);//结果为。。。。。。。。。。。。。。。。。。。。。。。。a:2    b:4    bo:false    c:3

9 Java结构及关键字

9.1 Java的三大基本结构

1. 顺序结构： Java中最基本、简单、明了的结构，程序按照自上而下的顺序依次执行.
2. 选择结构 ：根据条件真假来判断是否执行结构内的语句。
   if语句：选择结构中的一种，可以单独使用，也可以与else组成多选择结构，例如：

//猜猜小姑娘多少大了
package Test;
import java.util.Scanner;
public class Dome1 {
	public static void main(String[] args) {
		//猜猜小姑娘多少大了
		int age = 20;//设置答案为20岁
		int a;
		Scanner sca = new Scanner(System.in);//用于获取键盘的输入
		System.out.println("猜猜我多大？");
		a = sca.nextInt();//将输入的int型数值保存到a中
		
		if(a==age) {//如果括号的条件为真则执行这个大括号的语句，并结束，条件为假，则跳过，执行else if语句
			
			System.out.println("真棒！猜对了，就是"+a);
			
		}else if(a>age ) {//同理，条件为真，则执行并结束，为假跳过
			
			System.out.println("我才没这么大呢！");
			
		}else {//同理，条件为真，则执行，为假，因为后面再没有选择，所以直接结束本次结构选择
			
			System.out.println("我没有这么小哦！");
		}
	}

}

switch case语句:也叫多分支选择语句，根据表达式的值的不同执行不同的操作，例如：

//输入你的成绩显示评价，最高100分
package Test;

import java.util.Scanner;
public class Dome2 {
	public static void main(String[] args) {
		Scanner sca = new Scanner(System.in);
		System.out.println("考了多少分啊！");
		int a = sca.nextInt();
		switch (a/20) {//将一百分分为五个等级，a是int型的所以计算结果也会是int型，小数直接砍掉
		case 5:
			System.out.println("满分的大神啊！");
			break;//break表示停止循环，如果不加break在找出对应答案后会继续向下执行，直到遇到break或着本结构执行结束
		case 4:
			System.out.println("优秀啊！");
			break;
		case 3:
			System.out.println("还要继续努力呀！");
			break;
		case 2:
			System.out.println("得加油了，马上就能及格！");
			break;
		case 1:
			System.out.println("这次肯定是大意了！");
			break;
		case 0:
			System.out.println("肯定是老师阅错了！");
			break;
		default:       //default表示都不符合以上情况时需要执行的语句
			System.out.println("说归说，笑归笑，别拿成绩开玩笑！");
			break;
		}
	}

}

3. 循环结构
   for型循环语句
   语句格式：
   for(循环变量初始值；终止循环条件；变量改变方式){
   循环体
   }；
   for型语句 特点：最常用的循环语句，迭代灵活方便，循环体循环次数可设置，
   示例：

package Test;

import java.util.Scanner;

public class Dome1 {

	public static void main(String[] args) {
		//猜猜小姑娘多少大                     版本2.0
		//假设这个小姑娘只给你三次
		int age = 20;//设置正确答案为20岁
		int age1 = 0;//你的答案初始化为0
		Scanner sca = new Scanner(System.in);//用于获取键盘的输入
		System.out.println("猜猜我多大？");
		
		
		for(int i=0;i<3;i++) {//条件是猜的年龄不等于答案，猜错就一直猜（输入年龄）直到猜对才能进入下一步
			age1 = sca.nextInt();//先猜第一次
			if (age1 == age) {
				System.out.println("真棒！猜对了，就是"+age1);
				break; //break用于跳出循环，如果猜对则不用循环
				
			}else if(age1>age ) {//如果括号的条件为真则执行这个大括号的语句，并结束，条件为假，则跳过下次循环再判断
			
			System.out.println("我才没这么大呢！");//提示输入年龄太大
			
			}else {
			
			System.out.println("我没有这么小哦！");//提示输入年龄太小
			}
		}
		if(age1 != age) {
			System.out.println("真笨！我的年龄是："+age);
		}
		
	}

}

while型循环语句
语句格式：
while （循环终止条件）{
循环体
}；
while语句 特点：先进行条件判断，条件为真则执行循环体，没有循环次数限制，只要条件为真就循环。
示例：

package Test;

import java.util.Scanner;

public class Dome1 {

	public static void main(String[] args) {
		//猜猜小姑娘多少大                     版本3.0
		//假设这个小姑娘想让你一直猜，直到猜中为止（小姑娘真烦人！！！）
		int age = 20;//设置答案为20岁
		int age1;
		Scanner sca = new Scanner(System.in);//用于获取键盘的输入
		System.out.println("猜猜我多大？");
		age1 = sca.nextInt();//先猜第一次
		
		while (age1 != age) {//条件是猜的年龄不等于答案，猜错就一直猜（输入年龄）直到猜对才能进入下一步
		
		 if(age1>age ) {//如果括号的条件为真则执行这个大括号的语句，并结束，条件为假，则跳过下次循环再判断
			
			System.out.println("我才没这么大呢！");//提示输入年龄太大
			
		 }else {
			
			System.out.println("我没有这么小哦！");//提示输入年龄太小
			}
		 
		 age1 = sca.nextInt();//进入循环说明条件为真，确实猜错了，需要重新猜
		}
		System.out.println("真棒！猜对了，就是"+age1);//如果上一级循环结束则说明猜对了，直接输出答案
	}

}

do while循环语句
语句格式：
do {
循环体
}while(终止条件)
do while型语句 特点：先执行一次循环体，再根据终止条件判断是否继续循环。
三者区别：
for:循环次数确定，有三条语句控制循环
while：循环次数不确定，只有一条布尔表达式控制循环，先判断条件再确定是否循环
do while：循环次数不确定，只有一条布尔表达式控制循环，先执行一次循环体，再根据条件判断是否继续循环

9.2常见关键字总结（前期）

1. 定义访问权限关键字
   public（公共的）
   被public修饰的类、方法或字段可以被其他任何类或包引用
   protected(受保护的)
   被protected修饰的类、方法或字段只能被同一个包内的方法或类引用
   private(私有的)
   被private修饰的类、方法或字段只能被本类中的方法或内部类引用
2. 定义变量、类的关键字
   abstract(抽象的)
   用abstract修饰的类叫抽象类，抽象类不能直接实例化一个对象，需要被继承，而且里面的抽象方法必须要重写。
   用abstract修饰的方法叫抽象方法，抽象方法没有方法体，有抽象方法的类必须要用abstract修饰。
   final(不可变的)
   final可以修饰变量、方法和类，被final修饰的变量其数值一旦初始化之后便不能更改。
   修饰方法的作用是将一个方法锁定，使其任何继承类都不能修改它的含义。
   修饰类的作用是使这个类不能被继承，并且此类中的所有方法默认被final修饰。
   static(静态的)
   static可以修饰成员变量、成员方法、代码块和内部类
   static修饰的变量在该类加载时，类中所有静态变量都会被分配空间，所以就可以直接被调用，调用方式为类名.静态变量名。同样被static修饰的成员方法也可以直接被调用，调用方式为：类名.静态方法名。
   对于变量，若使用static final修饰，表示一旦赋值不能修改，并且通过类名可以访问。
   对于方法，若使用static final修饰，表示该方法不可被覆盖，并且可以通过类名直接访问。
   synchronized(线程、同步)
   synchronized 关键字可防止代码的关键代码段一次被多个线程执行。
3. 类、接口、实例的关键字
   extend
   类名A extend 类名B表示A继承B的属性、方法
   **interface **
   声明一个接口，必须由abstract修饰，接口中只能存在抽象方法和常量。且不能实例化只被实现。
   **implements **表示实现一个接口，格式为类名 implements 接口名 implements 接口名 .....一个子类只能继承一个父类但是可以实现多个接口
   new(新，创建)
   用于创建一个实例，格式为：
   实例类型A 实例a = new 构造方法A1；
   构造方法A1所在的类必须要和类型A相同或为A的子类。
   this(本类)
   this用于引用当前类的变量或方法
   super(父类)
   super必须放在该方法的第一行，用于表示调用父类的构造方法
4. 终止循环关键字
   break(退出)
   循环体中遇到break直接退出整个循环。
   continue(跳过)
   循环体中遇到continue跳过本次循环，进入下次循环

10 方法的形参与实参

形参：用来接收调用方法时的参数，不调时释放内存空间，（方法不调用时没有确定数值的参数）
实参：传递给方法的值，实参的值是确定的、具体的
示例：

package Test;

public class Dome3 {
	//定义一个带参方法
	public static int sum(int num1,int num2) {//num1,num2就是两个int类型的形式参数，没有确定值，在被调用时用于接收传递过来的参数
		return num1+num2;
	}
	
	public static void main(String[] args) {
		int S = sum(2,3);//调用sum方法时，传递给它的参数2，3就是实际参数，有确定的值
		System.out.println(S);
	}

}

11 方法的递归调用

递归调用：其核心思想就是自己调用自己，将一个较为复杂的问题，层层分化成多个简单的问题。
优点：代码简洁清晰，可读性号
缺点：由于递归需要系统堆栈，所以空间消耗要比非递归代码要大很多。而且，如果递归深度太大，可能系统撑不住。
多说无益，来实战演示：

package Test;

public class Demo4 {
	/**
	 * 计算n的阶乘（n！）
	 * n！=n*n-1*.....*3*2*1
	 * @param args
	 */
	public static void main(String[] args) {
		int number = f(5);//以5的阶乘为例,返回值为return 5*f(4*f(3*f(2*f(1))));
		System.out.println(number);
	}
	public static int f(int n) {//创建一个递归调用的方法f
		if(1==n) {              //第一步必须声明停止条件
			return 1;           //此时条件是当n等于1时返回值为1
		}else {
		return n*f(n-1);        //如果n不为1时,调用f方法,参数为n-1,层层向下，直到n为1
		}
	}
}