JavaSE【2】-基础语法
一、Java数据类型
在Java语言中将所有的数据类型划分为两大类： 八大基本数据类型 复合引用类型
八大基本数据类型：
|------数值型
|-整数类型： byte（字节） 、 short（短整型） 、 int（整型） 、long（长整型）
|-浮点类型： float（单精度） 、 double（双精度）
|------字符型 char
|------布尔型 boolean （取值 ： true | false）
复合引用类型：所有的类、数组、枚举、接口等都属于复合引用类型(除了8大基本数据类型之外的都是复合引用类型)；
提示！
整数类型
共有4种类型，各种类型的表数范围是不同的，所占的内存空间也是不同的。所以我们在使用的过程中一定是满足需要（1、能够表达我们想要的数据 2、同时能够进行空间的节约）就可以的。
long a = 4L;
所有的整数的常量值，系统默认的都是标准的32位的int类型；如果我们想表示出一个标准的long类型，需要在后面添加L或者l。
浮点类型
共有2种类型，各种类型的表数范围是不同的，所占的内存空间也是不同的。在使用的过程中需要进行平衡。float类型可以保留到小数点后7位。double类型可以保留到小数点后16位。精确有效位是不同的。
字符型：在Java中使用的是Unicode编码，占据的是2个字节。使用的是‘’单引号来进行定义的，但是需要注意的是其中有一部分是属于特殊字符，表达的就是特殊的含义。
//常规的使用情况
char c1 = '1';
char c2 = '中';
char c3 = 'a';
//java中的特殊字符
char c4 = '\t'; //表示的是制表符
char c5 = '\n';
char x = 'a';
System.out.println(x); //结果： a
System.out.println((int)x);// 97 按照的是ASCII码来进行处理的；
备注！
每一个字符都会对应唯一的一个ASCII码的值，它是int的一个子集，并且是没有负数的；具体的表数范围是：
0~65535区间。 a -- 97 b -- 98 ， A--65
特别提示！
所有的整数常量默认的都是int类型；
long x = 10L;
所有的小数常量默认的都是double类型；
float y = 2.5F;
二、数据类型转换
在8种基本数据类型之中，有如下这几种是直接存在数据类型由低到高的顺序的
byte < short (char) < int < long < float < double
低级类型------------------------------------> 高级类型
在Java语言中数据类型的转换有2种形式：
自动转换
当多种数据类型在一起进行混合运算的时候，低级类型直接会被提升为高级类型来进行处理；
byte x = 10;
int y = 20;
//x + y的时候，就进行了类型的自动转换（byte 自动转换为int类型了）
int sum = x + y;
-------------------------------
long a = 23L;
float b = 2.5F;
float result = a+b; //内部将long类型提升为float类型
强制转换
当高级类型需要转换为低级类型的时候，我们就必须要使用强制转换这种方式来操作，具体的写法是：
目标类型 变量名称 = (目标类型)（结果数据）;
eg：
//如果我最终需要将x+y定义为最终的byte类型，那么该如何操作呢？
//需要使用强制转换
byte x = 126;
int y = 20;
byte sum1 = (byte)(x+y); //结果：-110 解析过程： 146-256 = -110
System.out.println(sum1);
特别的提示！
以后在开发的过程中，我们尽量保证数据不变的情况下，发生类型的转换；
三、变量和常量
3.1、变量的定义
所谓的变量，就是一个可以变化的量，表示的是在计算机中申请一块内存空间，用于数据的存储。通过变量的这种形式可以对内存空间中数据进行不断的修改（重新赋值）。
3.2、变量的分类
在Java语言中变量可以分为2类：
第一类：
成员变量（全局变量）：就是定义在方法体之外，类体之中的位置；
第二类：
局部变量：可以定义在方法或者语句块中，为方法或者是语句块提供局部性的服务，随着方法的执行而创建，执行完毕
后就销毁，生命周期比较短。能够使用的修饰符只能是final ，其余的都不支持；
提示！
目前讲解和使用的都是成员变量；
3.2、成员变量定义的语法格式
修饰符 数据类型 变量名称 [ = 值];
解析：
1、修饰符：public static ；
2、数据类型：Java中所有的数据类型均可使用；
3、变量名称：符合标识符的定义规则即可（建议：最好有内涵）；
4、针对成员变量系统会自动默认初始化值，所以可以不进行手动赋值；
public class Demo02 {
//定义第一个成员变量
public static String name1="admin";
//定义第二个成员变量
public static String name2; //系统会自动初始化一个值，这个值就是这种类型的默认值 null
//入口程序（主方法）
public static void main(String[] args) {
//使用name1这个变量
System.out.println(name1);
//使用name2这个变量
System.out.println(name2);//null
}
}
提示！
1、注意成员变量的定义语法格式（包括位置）；
2、注意成员变量各种类型的默认初始化值；
byte：0 short：0 int:0 long:0L float:0.0F double：0.0 char：'\u0000' boolean:false
3、所有的复合引用类型的默认值都是null；
3.3、局部变量定义的语法格式
public class Demo03 {
public static void main(String[] args) {
//定义的局部变量
String name = "admin";
int age = 30;
//注意！局部变量不能使用修饰符，而且必须要手动赋值，只能是在局部范围内进行使用
//String name1; //是错误的
}
}
public class Demo03 {
//定义的一个成员变量
public static int age = 10;
public static void main(String[] args) {
System.out.println(age); // 10
age = 20;
System.out.println(age); // 20
age = 30;
System.out.println(age); //30
age = 'a';
System.out.println(age); //97
//age = "admin"; 这就是错误的
//观察发现：同样是一个age的变量，在程序执行期间的不同阶段，其值是不同的；
//在计算机中的同一块内存中，可以保存一些不同的值，只要是类型兼容即可；
}
}
3.4、常量的定义
所谓的常量，就是一个值不能变化的变量，在声明和定义的时候必须要手动赋值，并且需要使用final修饰符来进行限制；
3.5、常量的定义语法
修饰符 final 数据类型 常量名称 = 值;
说明：
修饰符：public static + final
数据类型：所有的Java数据类型都是可以的；
常量名称：都是使用大写；
=值 ： 常量必须要手动赋值；
/**
* 常量的讲解和使用
* @author Administrator
*/
public class Demo04 {
//定义一个常量
public static final String NAME = "admin";
public static void main(String[] args) {
System.out.println(NAME);
//NAME = "guest"; 针对常量就不能重新进行赋值操作
}
}
四、运算符
在Java中所有的运算符被划分为以下几类：
4.1、算术运算符
+ - * / % ++ --
/**
* 针对 / 除法的使用
* @author Administrator
*/
public class Demo05 {
public static void main(String[] args) {
//局部变量
int x = 10;
int y = 3;
int result = x/y;
System.out.println(result); //3
double z = 10.0;
double result1 = z/y;
System.out.println(result1); //3.3333333333333335
//注意！所有的浮点型表示的都是一个近似值
double a = 10.0;
double r1 = a/0; // 0.0
System.out.println(r1); // Infinity 正无穷（无穷大）
double b = -10.0;
double r2 = b/0;
System.out.println(r2); // -Infinity 负无穷（无穷小）
double result2 = r1 + r2;
System.out.println(result2); // NaN 非数字
}
}
// % 求模 （求余数）
public class Demo06 {
public static void main(String[] args) {
int a = 10;
int b = 3;
int result = a%b;
System.out.println(result);
}
}
++ 的使用
public static void main(String[] args) {
int a = 10;
System.out.println(a); // 10
a++; //将a自身+1；
System.out.println(a); // 11
//a++ ： 首先将a的值带入运算，再自身+1
int result = a++;
System.out.println(result); // 11
System.out.println(a); // 12
//++a : 首先自身+1，再带入运算
result = ++a;
System.out.println(result); // 13
}
4.2、逻辑运算符
&& || !
//逻辑运算符
public static void main(String[] args) {
//&&的使用情况
System.out.println(true&&true); //true
System.out.println(true&&true&&true); //true
System.out.println(true&&true&&false); //false
//&&表示的是：一些列的表达式结果，只要有一个为false，则整体的结果为false；
System.out.println(true&&false&&true); //false
//注意！当程序检查到第二个false的时候，就可以给出整个表达式的结果了，后续的结果不做参考，所以&&表示的是“短路版”模式，有利于提高性能；
int a = 5;
int b = 7;
int c = 10;
System.out.println((a>b)&&((c+b)<a)&&(b>c)); //false
//注意！以后的复杂程度，主要是取决于表达式的复杂度，但是每个表达式的最终结果必须要是boolean类型才可以；
System.out.println("---------------------------------------------------------");
System.out.println(true||true||true); //true
System.out.println(true||false||true); //true
System.out.println(true||false||false); //true
//提示！只要有一个表达式的结果为true，则整个表达式的最终结果就为true，而且后续的表达式不做任何的检查。有利于提高处理性能；
System.out.println((a>b)||(a+c)<b||(b-a)>c); //false
//注意！以后的复杂程度，主要是取决于表达式的复杂度，但是每个表达式的最终结果必须要是boolean类型才可以；
// !取反（true--false，false - true）
System.out.println(!true); //false;
System.out.println(!(a>b));//true
}
重点提示！
针对&& 和 || 都是基于“短路板”的模式，有利于提高处理的性能；
4.3、赋值运算符
= += -= *= /= %=
//赋值运算符及扩展运算符
public static void main(String[] args) {
int a = 10; //将10这个数据值，赋值，给a这个int类型的变量；
a+=5; //这个表达式的计算过程可以理解为： a = a+5 , 但是其内涵是不同的；
System.out.println(a); // 15
byte x = 4;
//x+=5; 这种写法内部已经进行了相应的强制转换处理，并不完全等价于 x = x + 5的写法。
x = (byte)(x + 5);
System.out.println(x); // 9
int y = 10;
int z = 3;
y%=z; // y=y%z;
System.out.println(y); // 1
}
4.4、比较运算符
> < == >= <= !=
注意！
以上的这些比较运算符，都是可以用于具有可比性（大小之分）的数据；其中 == 和 != 可以用于boolean类型，其他的则不可以；
4.5、位运算符
位运算符是基于二进制的处理，了解即可；
五、Scanner类
Scanner是Java平台内部提供给我们的一个类（就像我们前面所使用的String一样），主要是用于针对控制台进行数据的录入和扫描，增强程序的互动性，这个类是位于java.util包之下的。
5.1、如何创建
Scanner sc = new Scanner(System.in);
5.2、如何使用Scanner
Scanner实现原理:
package com.it.www;
//使用的是java内部提供的Scanner类，这是一个导包的语法
//表示的是告诉我们Scanner这个类的位置
import java.util.Scanner;
public class Demo11 {
public static void main(String[] args) {
//在程序中产生出一个提示信息
System.out.println("请输入您的姓名:");
//创建出一个扫描器
Scanner sc = new Scanner(System.in);
//扫描数据
String name = sc.next();
System.out.println("输出到控制台："+name);
}
}
/**
* Scanner扫描器的使用
* @author Administrator
*/
public class Demo12 {
public static void main(String[] args) {
//创建扫描器
Scanner sc = new Scanner (System.in);
System.out.println("请输入文本信息:");
String text = sc.next();
System.out.println("请输入数据信息:");
//扫描4种整数类型
sc.nextByte();
sc.nextShort();
sc.nextInt();
sc.nextLong();
//扫描2种浮点类型
sc.nextFloat();
sc.nextDouble();
//扫描boolean类型
sc.nextBoolean();
//扫描字符('男' --- next()----"男" ------ "男".charAt(0) ----- '男' )
char c = sc.next().charAt(0);
//扫描字符串
sc.next();
}
}
六、Math类
6.1、Math的使用
Math类也是Java平台内部为我们提供的一个类，这个类位于java.lang包下，主要负责数学运算方面的处理，比如开平方、正弦、最大值、最小值.....;
//Math类的使用
public static void main(String[] args) {
int x = -10;
int y = 2;
//求绝对值
int r1 = Math.abs(x);
System.out.println(r1);// 10
int max = Math.max(x, y);
System.out.println(max);
int min = Math.min(x, y);
System.out.println(min);
double pi = Math.PI;
System.out.println(pi); // 3.141592653589793
//ran这个随机数的值区间： [0.0 , 1.0)
double ran = Math.random();
System.out.println(ran); //0.9801505916722769
//0.9545355138678769
}
6.2、Scanner 和 Math的总结
1、这2个类都是由Java平台内部提供的类；
2、Scanner类是位于java.util包下，Math类是位于java.lang包下，我们发现在使用的过程中，Math不需要我们进
行导包的操作（因为JVM默认的已经将java.lang包进行了导入）。
3、Scanner的使用需要创建对象，而Math类没有创建对象，是直接进行使用的；
--原因：Scanner类中的方法都是非静态的方法，所以必须要先创建对象，否则无法访问和使用；
Math类中都是静态的方法，而静态的方法是不需要我们创建对象的，可以通过类名直接进行使用；
提示！
针对Scanner类中的方法 和 Math类中的方法，我们可以通过源码来进行观察！
重点去区分静态和非静态方法的含义和使用方式。
七、方法的定义和调用
7.1、何为方法
【Java中的类 = 属性 + 方法 】 永远都是成立的；
一个类描述的是某一类事物，而这个事物所具备的特点就是属性，这个事物所具备的行为功能就是我们所说的“方法”。
方法就是针对具体的某一个功能进行的处理，由相应的Java程序代码所构成。
7.2、如何定义方法
修饰符 [static] 方法返回类型|void 方法名称([参数1，参数2，......]){
//方法主体部分（方法体）
}
说明提示！
1、修饰符： public
2、返回类型：可以是Java中的任意数据类型
3、void ：表示没有返回值
4、方法名称：符合标识符的规范即可（推荐：动词+名词形式）
5、参数列表：数据类型 + 变量名称 所构成，可以是多个
6、{ }：其中编写的是Java程序代码
Demo01.java 【定义的全部都是静态方法】
//自定义方法-1 （特点 ： 1、属于静态方法 2、无返回的方法 3、没有参数列表的方法）
public static void method01(){
int a = 20;
int b = 15;
//求出最大值
int max_value = Math.max(a, b);
//输出最大值
System.out.println(max_value);
}
//自定义方法-2（特点：1、属于静态方法 2、有返回值的方法 3、没有参数列表）
public static int method02(){
int a = 20;
int b = 15;
//求出最大值
int max_value = Math.max(a, b);
return max_value;
}
/**
* 注意！
* 1、有返回值的方法必须要使用return关键字；
* 2、return后面的变量或者值，必须要兼容方法定义的返回类型；
* 3、有返回值的方法，最终将值返回到方法的调用处（哪里调用就返回给哪里）；
*/
//自定义方法-3 （特点： 1、属于静态方法 2、有返回值的方法 3、有参数列表）
public static int method03(int a, int b){
int max = Math.max(a, b);
return max;
}
/**
*参数列表就是为这个方法所提供的原材料，可以是多个不同类型的参数；
*/
Demo02.java 【定义的全部都是非静态的方法】
//自定义方法-1 (特点：1、属于非静态的方法 2、无返回值 3、无参数列表)
public void method01(){
int a = 30;
int b = 20;
int max = Math.max(a, b);
System.out.println(max);
}
//自定义方法-2 (特点：1、属于非静态的方法 2、有返回值 3、无参数列表)
public int method02(){
int a = 30;
int b = 20;
int max = Math.max(a, b);
return max;
}
//自定义方法-3 (特点：1、属于非静态的方法 2、有返回值 3、有参数列表)
public int method03(int a, int b){
int max = Math.max(a, b);
return max;
}
7.3、方法的分类
在Java的类中所有的方法被分为2大类：
a、静态方法：
修饰符中必须要含有static关键字，在调用的时候可以直接通过【类名.方法名称】进行调用；
b、非静态方法：
修饰符中没有static关键字，在调用的时候必须要首先创建出这个方法所在类的对象，再通过【对象.方法名称】
进行调用；
7.4、方法的调用
针对Demo01类中的所有的静态方法的调用：
//调用方法-1
//method01();
//需求： 在外部通过方法得到最大值20，然后再 +10，最终进行输出
//调用方法-2
/*
int result = method02();
//result = result+10;
result+=10;
System.out.println(result);*/
//调用方法-3
//在调用的时候，给出的是实际的参数（简称为“实参”）
/*int result = method03(120, 39);
System.out.println(result);*/
/**
* 以上针对下面的3个静态方法进行调用的时候，我们直接通过方法名称来实现调用的。
* 也可以通过【类名.方法名称】进行调用
* 所有的静态的方法也可以通过创建对象，再使用【对象.方法名称】，但是我们一般不这么做（因为创建对
* 象需要进行性能的消耗）。
*/
Demo01.method01();
int result = Demo01.method02();
System.out.println(result);
result = Demo01.method03(50,100);
System.out.println(result);
/**
* 由于这些静态的方法都是位于Demo01这个类中的，并且是在Demo01类中的main方法中进行调用的，所以
可以省略Demo01这个类名;
* 所以：如果以后我们在调用方法的时候跨类了，那么就必须要写类名。
*/
针对Demo02类中的所有的非静态的方法的调用：
//想要调用Demo02这个类中的非静态方法，首先需要创建Demo02这个类的对象
Demo02 demo = new Demo02();
//通过demo对象进行方法的调用
//demo.method01();
/*int result = demo.method02();
System.out.println(result);*/
//传入的是实际参数40和60
int result = demo.method03(40, 60);
System.out.println(result);