java.基础知识

变量#

变量是指内存中的一个存储区域，该区域要有自己的名称（变量名）、类型（数据类型）、该区域的数据在同一个数据类型的范维内不断变化值。
每个变量都有自己的作用范围，叫做作用域。

注意事项

1、Java中的变量必须声明后才能进行使用。否则编译报错。
2、变量在使用之前必须要进行初始化才能使用变量，否则编译报错。
3、不允许在同一段代码区域中声明相同名称的变量，否则编译报错。
4、每个变量都有自己独立的作用域（作用范围），变量的作用域：在一对{}中为有效区间。
5、在main（）方法中声明的变量叫做局部变量，局部变量的作用范围：从声明开始到方法体结束。

声明和使用

声明：数据类型 变量; 例如： int age;
赋值：变量名 = 值; 例如：age = 20;
声明同时赋值：数据类型 变量名 = 值; 例如：int age = 20;
使用：通过变量名访问变量的值；例如：System.out.println(age);

public class TestVar{
	public static void main(String[] args){
		//s声明变量
		int age;
		//初始化变量
		age = 20;
		//打印变量
		System.out.println(age);

		//声明并初始化变量
		String name = "leesin";
		//打印变量
		System.out.println(name);
	}
}

输出结果

20
leesin

数据类型#

什么是数据类型

数据类型是为了区分不同特点的数据而数据类别。
数据类型分类：
    Java分为”基本数据类型“和”引用数据类型“
基本数据类型有8种。
引用数据类型包括所有的：数组、类、接口、枚举、和标注。
枚举可以看成特殊的类，标注可以看出成特殊的接口。

基本数据类型

基本数据类型是Java事先定义好的 ，用关键字命名的数据类型。
基本数据类型分为：
    整型：byte、short、int、long
    浮点型：float、double
    字符型：char
    布尔型：boolean

整型

用于表示整数（不包含小数部分）的基本数据类型
根据分配的内存空间大小不同，又分为四种类型

数据类型	占用的空间大小	取值范围
byte（字节型）	8位，1个字节	-128（-2^7）~127（2^7-1）
short（短整型）	16位，2个字节	-32768（-2^15）~32767（2^15 - 1）
int（整型）	32位，4个字节	-2,147,483,648（-2^31）~2,147,483,647（2^31 - 1）
long（长整型）	64位，8个字节	-9,223,372,036,854,775,808（-2^63）~9,223,372,036,854,775,807（2^63 -1）

浮点型

浮点型是表示浮点数的基础类型
    单精度浮点型：float（需使用F/f进行标明） 例如：float number = 1.5f
    双精度浮点型：double（默认类型） 例如： double numble = 5.15

数据类型	占用的空间大小	取值范围
float（单精度浮点型）	32位，4个字节	1.4E-45~3.4028235-E38
double（双精度浮点型）	64位，8个字节	4.9E-324~1.7976931348623157E-308

字符型

以char关键字进行标识
字符型用于保存单个字符或汉字
char采用unicode编码方式（8位的ASCII码包含在其中）
字符型占两个字节（也可可以赋值0-65535的数字）

public class TestVar{
	public static void main(String[] args){
		//声明char类型变量，赋值字符串a
		char char_word = 'a';  //字符型变量赋值需要使用单引号	
		//声明char类型变量，赋值97
		char char_temp = 97;  //字符a对应的ASCII码就是97
		//输出两个变量查看值
		System.out.println("char_word变量输出结果是："+char_word);
		System.out.println("char_temp变量输出结果是："+char_temp);
	}
}

输出结果

char_word变量输出结果是：a
char_temp变量输出结果是：a

布尔型

布尔型是用于表示逻辑状态（TRUE和FALSE）的基本数据类型
布尔型特点：
    用boolean关键字标识
    只有明确的两种值，true或者false

public class TestVar{
	public static void main(String[] args){
		//创建boolean类型变量b_first 并赋值true；
		boolean b_first = true;
		//创建boolean类型变量b_second 并赋值false；
		boolean b_second = false;
		//输出两个变量查看值
		System.out.println(b_first);
		System.out.println(b_second);
	}
}

输出结果

true
false

数据类型转换#

整型、实型（常量）、字符串类型可以混合运算。运算中，不同类型的数据先转化位同一类型，然后进行运算。
转换从低级到高级
byte、short、char->int->long->float->double

转换规则

1、不能对boolean类型进行类型转换
2、不能把对象类型转换成不相关类的对象
3、在把容量大的类型转换位容量小的类型时必须使用强制类型转换
4、转换过程中可能导致溢出或损失精度。例如：
    int i= 128;
    byte b = (byte)i;
    因为byte类型时8位，最大值位127，所以当int强制转换位byte类型时，值128就会导致溢出。
5、浮点数到整数的转换时通过舍弃小数的到的，而不是四舍五入。例如：
    (int)23.7 == 23;
    (int)-45.89f == -45;

自动类型转换

必须满足转换前的数据类型的位数要低于转换后的数据类型，例如：short数据类型的位数位16位，就可以自动转换位数为32位的int类型，同样float的数据类型位数为32，可以自动转换为64为的double类型。

案例

public class Test{
    public static void main(String[] args){
    	char c1 = 'a';//定义一个char类型
	    int i1 = c1;//char自动类型转换为int
	    System.out.println("char自动类型转换int后值为：" + i1);
    	char c2 = 'A';//定义一个char类型
	    int i2 = c2+1;//char类型和interesting类型计算
	    System.out.println("char类型和int计算后的值等于：" + i2);
    }
}

运行结果为

char自动类型转换int后值为：97
char类型和int计算后的值等于：66

解析：c1的值为字符a，ASCII码表中对应的int类型值为97，A对应的值为65，所以i2 = 65+1 =66

强制类型转换

1、转换的数据类型必须是兼容的
2、格式：(type)value type是强制类型转换后的数据类型

案例

public class Test{
    public static void main(String[] args){
	    int i1 = 123;
	    byte b = (byte)i1;//强制类型转换为byte
	    System.out.println("int强制转换类型为byte后的值等于：" + b);
    }
}

运行结果为

int强制转换类型为byte后的值等于：123

隐含强制类型转换

整数的默认类型为int类型，当把一个整数赋值为byte类型时，其实默认有一个强制类型转换，编译器会判断这个整数是否在byte类型的范围之内，true则会被赋值，就是隐含强制类型转换，false则报不兼容错误。

规则

1、整数的默认类型是int
2、浮点型不存在这种情况，因为在定义float类型是必须在数字后面跟上F或者f

案例

public class Test{
    public static void main(String[] args){
	    byte b = 3; //定义b的数据类型，并赋值
	    b = 6+10;
	    System.out.println(b); 
    }
}

输出结果

隐含强制类型转换后：16

编译报错案例

public class Test{
	public static void main(String[] args){
		byte b = 3; //定义b的数据类型，并赋值
		byte b1 = 4;
		byte b2 = 5;
		b = b1+b2;
		System.out.println(b); 
	}
}

输出结果

Test.java:6: 错误: 不兼容的类型: 从int转换到byte可能会有损失
            b = b1+b2;

解析

    第一段代码被赋值的是常量，编译器先计算表达式的结果，判断结果在byte范围之内于是就把int类型强制转换为byte赋值给b；
    第二段代码被赋值的是变量，变量的值是不确定的，编译器无法判断是否超出byte类型的取值范围，没办法进行强制转换；

运算符#

运算符也称为操作符，用于数据计算和处理，或改变特定对象的值。运算符按其操作数的个数类分，可分为一元运算符、二元运算符和三元运算符/按照运算符对数据的操作结果分类可以分为以下几种。

算术运算符#

+ 加  -减 *乘  /除  %取余 
整数运算时，0不能作为除数，浮点运算时，0.0可以，但是结果无穷大
注意事项：
    1、当两个整数进行除法运算时，结果只取整数部分，小数部分舍弃
    2、当希望结果中保留小数部分，具体方法如下：
        a.将其中一个操作数强转为double类型再做运算
        b.将其中一个操作数乘以1.0提升为double类型再运算（推荐）
    3、0不能作为除数，否则产生 算术异常：/by zero 。但是0.0可以作为除数但是结果无穷大，编程中尽量避免0和0.0作为除数

测试demo

连接运算符#

“+”可以实现字符串的连接。同时可以实现字符串与其他数据类型的相连
注意事项：
    1、当+两边的操作数中只要有一个字符类型，则按照字符连接符类处理，结果依然是字符
    2、当+两边的操作数都不是字符串时，则按照算术运算符来处理

测试demo

自增减运算符#

+ 表示加法或连接 ++ 表示自增，也就是让自身的数值加1
- 表示减法 -- 表示自减，也就是让当前变量自身的数值减1
++（--）可分为前++（--）和 后++（--）

    当++在前时先进行加1的操作，然后再进行其他运算
    当++在后时前进行其他运算，然后再进行加1的操作
    -- 同理，也就是无其他*或/等运算符参与时在前在后结果并无区别

测试demo

赋值运算符#

    赋值运算符将右边表达式得运算结果赋值给左边变量得运算符
1、简单赋值
    = 表示赋值运算符，用于将=右边得数据赋值给=左边得变量，覆盖改变了原来得数值
2、复合赋值
    = 、+= 、-= 、*= 、/= 、%=

测试demo

比较运算符#

比较运算符是用来判断两个表达式或值大小得关系运算符
    >   表示是否大于
    <   表示是否小于
    == 表示是否等于
    <= 表示是否小于等于
    !=  表示是否不等于
    >= 表示是否大于等于
关系运算符参与得表达式最终结果为boolean类型， True（真）和False（假）

测试demo

逻辑运算符#

逻辑运算符操作数为boolean表达式
java提供的逻辑运算符有 &&（与） ||（或） ！（非）  
    &&（与） 表示逻辑与运算符，相当于“并且”，同真为真，一假为假
    ||（或）    表示逻辑或运算符，相当于“或者”，一真为真，同假为假
    ！（非）    表示逻辑非运算符，相当于“取反”，真为假，假为真
&& 和 || 具备短路的特性：如果通过第一个表达式的是即可得出最后的结果则不计算第二个表达式
    短路的特性：
        &&：若第一个条件为假则整个表达式一定为假，此时跳过第二个条件的执行
        ||  ： 若第一个条件为真则整个表达式一定为假，此时跳过第二个条件的执行

测试demo

条件/三目运算符#

语法格式
    数据类型 变量名称 = 条件判断 ？ 表达式A ： 表达式B
    
执行流程
    判断条件是否成立
        若成立为ture，将表达式A的值赋值给左侧的变量
        若不成立为false，将表达式B的值赋值给左侧的变量
注意事项：
    1、必须同时保证表达式A和表达式B都符合左侧数据类型的要求
    2、三元运算符的结果必须被使用

测试demo

 
public class TestThreeEye {    
    public static void main(String[] args) {        
        int a = 10;        
        int b = 20;       
        //数据类型 变量名称 = 条件判断 ？ 表达式A ： 表达式B        
        int max = a > b ? a : b;        
        System.out.println("最大值是："+max);        
        //注意：必须同时保证表达式A和表达式B都符合左侧数据类型的要求       
        //int result = 3 > 4 ? 2.5 : 4;//Error:(13, 28) java: 不兼容的类型: 从double转换到int可能会有损失       
        //注意：三元运算符的结果必须被使用        
        //System.out.println(a > b ? a : b);//直接输出是正确写法        
        //a > b ? a : b；//不是语句，错误写法    
        }
}
  

选择结构#

当需要进行条件判断的时候，并且根据条件是否成立来选择执行某一段代码的时，需要选择结构。

if#

1、语法
    if（条件表达式）{
        语句块1； -----多条语句的集合，也可以是一条语句。
    }
        语句块2；
2、执行流程
        判断条件表达式是否成立
            假如条件成立，则执行语句块1，执行语句块2
            假如不成立，则执行语句块2

演示英雄选择

if-else#

1、语法
    if（条件表达式）{
        语句块1；
    }
    else{
        语句块2；
    }
    语句块3
    
2、执行流程
    判断条件是否成立
        若成立，执行语句块1，执行语句块3；
        不成立，执行语句块2，执行语句块3；

演示一个简单的考试成绩判断

if-else if-else#

1、语法
    if（条件表达式1）{
        语句块1；
        }else if（条件表达式2）{
        语句块2；
        }else{
        语句块3；
        }
        语句块4；
2、执行流程
        判断条件表达式1是否成立
                成立，执行语句块1，执行语句块4
                不成立，判断条件表达式2是否成立
                        成立，执行语句块2，执行语句块4
                        不成立，执行语句块3，执行语句块4

演示一个简单的买购票系统

swich-case#

1、语法
    swich（）{
        case 字面值1：
            语句块；
            break；
        case 字面值2：
            语句块2；
            break；
        default：
            语句块3；
          
    }
        语句块4；
2、执行流程
    计算变量/表达式的数值  判断是否匹配字面值1；
        如果匹配，则执行语句块1，执行语句块4；
        如果不匹配，则判断是否匹配字面值2；
            匹配，则执行语句块2，执行语句块4；
            不匹配，则执行语句块3，执行语句块4；

演示一个简单的买购票系统

循环结构#

当需要在某个场合进行条件的判断，有所选择的执行一段代码，需要分支结构
当需要在某个场合重复去做某一件事，需要循环结构

for循环#

1、语法
    for（初始表达式;条件表达式；修改初始表达式的表达式）{
        循环体1；
    }
        循环体2；
2、执行流程
    执行初始表达式=》判断条件表达式是否成立
        成立 执行循环体1=》修改初始条件测表达式=》判断条件表达式是否成立
        不成立 执行循环体2
 注意：
    for（初始表达式;条件表达式；修改初始表达式的表达式）{
        循环体1；
    }
    for循环的括号和大括号中声明的变量都叫做块变量，作用域只限于for循环，而再方法中声明的变量称之为局部便变量，作用域包含整个方法 

循环输入5个商品的价格，并计算平均价格

while循环#

1、语法
    while(条件表达式){
        循环体；
    }
        语句块

2、执行流程
    判断条件表达式是否成立
        成立，执行循环体 =》判断条件表达式是否成立
        不成立，执行语句块
 3、注意
    while循环和for循环是可以互补的
    while循环通过使用明确循环条件但不明确循环册数的场合中
    for循环通常使用再明确循环次数/范围的场合中使用
    for（；；）{} 和 while（true）{} 都是表示无限循环的方式

While循环打印1-10

 
public class TestWhile {
	public static void main(String[] args) {
		int i = 0;
		while(i<=10) {
			System.out.println(i);
			i++;
		}
		System.out.println("跳出while循环");
	}
}
  

do-while#

1、语法
    do{
        循环体；
    }while（条件表达式）；
    语句块；
    
2、执行流程
        执行循环体=》判断条件表达式是否程立
            成立。执行循环体=》判断条件表达式是否成立
            不成立，执行语句块
3、注意
    do-while循环通常使用再至少需要执行一次循环体的场合中，而while循环可以不执行 

do-while打印1-10

 
public class TestDoWhile {
	public static void main(String[] args) {
		int i=1;
		do {
			System.out.println(i);
			i++;
		}while(i<=10);//do-while循环结构在小括号的后面有分号，其他循环则没有		
	}
}
  

三个循环的区别

执行顺序
    while 循环： 先判断，再执行
    do-while循环：先执行，再判断
    for循环；先判断，再执行
适用情况
    循环次数确定的情况，通常选用for循环
    循环次属不确定的情况，通常选用while或者do-while循环

数组#

数组是一组数据类型相同的数据的组合，将这些数据统一的管理起来
数组是一个引用数据类型,数组内存的类型可以是基本类型，也可以是引用类型

别人的讲解

数组的定义（声明）

数据类型[] 数组名字：
    int[] x;
    char[] y;
    boolean[] z;
    String[] m;
其他的定义方式：
    int x[];
    int []x;

数组的赋值（初始化）

静态初始化  有长度 有元素
    int[] array = new int[]{10,23,30,40,50};
    int[] array = {10,20,30,40,50};
动态初始化  有长度 没有元素（不是真的没有 是保存默认值）
    int[] array = new int[5];
    整数默认值--0
    浮点数默认值--0.0
    字符类型默认值--char对应0的字解码  比如 97对应a 65对应A 48对应‘0’
    布尔型默认值--false
    引用数据默认值--null

访问元素

通过元素在数组的位置index（索引/下标）来访问
索引是有取值范围的【从0开始-数组长度-1】
如果数组的索引超出了上述范围
会出现一个运行异常 ArrayIndexOutOfBoundsException (数组索引超出边界)

数组元素的遍历（轮询）

通过循环的方式访问数组的每一个元素
JDK1.5版本之后 新的特性 增强for循环： forEach
for(自定义的变量（用于接收数组内的每一个元素）: 遍历的数组Array){
}

正常的for 
    有三个必要条件 index索引 找到某一个位置
    可以通过index直接访问数组的某一个位置 存值 取值都可以
增强的for
    有两个必要条件 用来取值的变量 用来的遍历的数组 没有index索引
    不能存值 只能取值
    没有index索引 找不到元素到底是哪一个

数组练习#

用数组来存储1-100之间的奇数

public class Test0 {
    public static void main(String[] args){
        //静态初始化a、b数组
        int[] a = new int[]{1,2,3,4};
        int[] b = new int[]{5,6,7,8};

        //堆内存的数组空间长度一旦确定 不能再次发生改变。那我们定义一个动态数组器调换元素作用
        int[] x = new int[4];

        //for循环将a数组中的元素赋值到x数组中，现在x{1,2,3,4}
        for (int i=0;i<a.length;i++){
            x[i] = a[i];
        }

        //for循环将b数组中的元素赋值到a数组中，现在a{5,6,7,8}
        for (int i=0;i<a.length;i++){
            a[i] = b[i];
        }
        //for循环将x数组中的元素赋值到b数组中，现在b{1,2,3,4}
        for (int i=0;i<a.length;i++){
            b[i] = x[i];
        }

        //while循环遍历替换后的a和b中的元素
        int z = 0;
        while(z<a.length){
            System.out.println(a[z]);
            System.out.println(b[z]);
            z++;
        }
    }
}

a{1,2,3,4} b{5,6,7,8}内的元素位置对应互换

public class Test1 {
	public static void main(String[] args) {
		//将数组a{1、2、3、4} b{5、6、7、8}内的元素位置对应互换
		
		//1、每次循环将两个数组中对应位置的元素互换（循环对此，受长度限制）
		int[] a = {1,2,3,4};
		int[] b = {5,6,7,8};
		
		for(int i = 0;i<a.length;i++) {
			int x = a[i];
			a[i] = b[i];
			b[i] = x;
			System.out.println(a[i]);
			System.out.println(b[i]);
  		}
		
		//2、直接交换数组a和b数组的引用地址（不用循环，不受长度限制）
		int [] y = a;
		a = b;
		b = y;
		for(int z : a) {
			System.out.println(z);
		}
		for(int z : b) {
			System.out.println(z);
		}
	}
}

a{1,2,3,4,5,6}内的元素位置逆向调换

public class Test2 {
	public static void main(String[] args) {
		//静态生成一个数组
		int[] a = new int[]{1,2,3,4,5,6,7,7,9};
		//通过第三个int元素介入，每次循环从外向内进行元素互换
		for(int i=0;i<a.length/2;i++) {
			int x = a[i];
			a[i] = a[(a.length-1)-i];
			a[(a.length-1)-i] = x;
		}
		for(int y:a) {
			System.out.println(y);
		}
	}
}

a{1,2,3,4,5,6}计算数组所有元素的平均值

public class Test3 {
    public static void main(String[] args){
        //静态定义一组数据
        int[] a = new int[]{1,2,3,4,5};
        //定义一个数值为0的int类型变量，用于接收a数组内的元素进行相加
        int sum = 0;
        //while遍历数组a中的元素，进行相加
        int i = 0;
        while(i<a.length){
            sum = sum+a[i];
            i++;
        }
        //打印出平均值
        System.out.println(sum/a.length);
    }
}

{1,3,5,7,9,0,2,4,6,8}找出最大值和最小值

public class Test4 {
    public static void main(String[] args){
        /*
         *  1、定义一个值为0的int数据类型对象，用来接收a数组的元素
         *  2、遍历a数组的元素，没次赋值给int对象
         *  3、下一次遍历是判断当前int对象和上一次遍历被赋值的int对象谁更大，
         *     如果当前遍历对象更大则进行赋值，更小则进行下一次遍历。
         *  4、最小值思路反之
         */


        //静态定义一数组
        int[] a = new int[]{1,3,5,7,9,0,2,4,6,8};

        int MaxNum = 0;
        for(int i = 0;i<a.length;i++){
            if(a[i]>MaxNum){
                MaxNum = a[i];
            }
        }

        int MinNum = 0;
        for(int x = 0;x<a.length;x++){
            if(a[x]<MinNum){
                MinNum = a[x];
            }
        }
        System.out.println("a数组中的最大值是："+MaxNum);
        System.out.println("a数组中的最小值是："+MinNum);
    }
}

a{1,2,3} b{4,5} 合并两个数组

public class Test5 {
	public static void main(String[] args) {
		//创建两个数组
		int[] a = {1,2,3};
		int[] b = {4,5};
		//创建一个新数组向内添加内容
		int[] NewArray = new int[a.length+b.length];
		//将a数组的元素添加进NewArray
		for(int i = 0;i<a.length;i++) {
			NewArray[i] = a[i];
		}
		//将b数组的元素添加进NewArray
		for(int i = 0;i<b.length;i++) {
			NewArray[a.length+i] = b[i];
		}
		//遍历输出NewArray
		for(int x:NewArray) {
			System.out.println(x);
		}
	}
}

{5,4,2,3,1}升序排列

public class Test6 {
	public static void main(String[] main) {
		int[] a = { 5, 4, 2, 3, 1 };
		for (int x = 1; x < 5; x++) {//重复执行升序循环
			for (int i = 4; i >= x; i--) {//找出一个最小数进行升序替换
				// 如果后面的数比前面的数大，就进行替换
				if (a[i] < a[i-1]) {
					int change = a[i];
					a[i] = a[i-1];
					a[i-1] = change;
				}
			}
		}
		for (int x : a) {
			System.out.println(x);
		}
	}
}

二维数组#

一维数组本质上就是一段连续的内存空间，用于存放多个类型相同的数据。
二维数组本质就是有一堆数组组成的数组，其实就是每个元素为一组数组的数组。

定义格式

格式1：
    数据类型[][] 变量名 = mew 数据类型[m][n];
    m表示这个二维数组有多少个一维数组
    n表示每一个一维数组的元素个数
举例：
    int[][] arr =new int[3][2];
    定义一个二维数组arr
    这个二维数组有3个一维数组，名称为arr[0],arr[1],arr[2]
    每一个以一维数组有2个元素，可以通过arr[m][n]来获取元素

格式2：
    数据类型[][] 变量名 = new  数据类型[][]{{元素}，{元素}，{元素}}；
    数据类型[][] 变量名 = {{元素}，{元素}，{元素}}；
举例：
    int[][] arr =   {2，9}，{1，2，3}，{4，5}；

数组的初始化

静态初始化
    int[][] array = {{1,2},{3,4,5},{6,7,8,9}};
动态初始化
    int[][] array = new int[3][2];
        array --> {{x,x},{x,x},{x,x}}

二维数组练习#

求公司年销售额总额

某公司按季度和月份统计的销售数据如下：单位（万元）
第一季度：22，44，66
第二季度:77，55，66
第三季度：60，48，50
第四季度：70，58，66

public class ArrsTest {
     public static void main(String[] args) {
         //初始化一个二维数组
         int[][] arr = {{22,44,66},{77,55,66},{60,48,50},{70,58,66}};
         //初始化一个int类型变量，用来接收最后的总额
         int x = 0;
         //第一个循环用来输出二维数组中有多少个一维数组
         for(int i =0;i<arr.length;i++) {
              System.out.println("我是第"+(i+1)+"季度");
              //第二个循环用来输出每个一维数组，并将值赋给x
              for(int j = 0;j<arr[i].length;j++) {
                  System.out.println(arr[i][j]+"万");
                  x += arr[i][j];
              }
         }System.out.println("全年销售总额为："+x+"万");
     }
}

我是第1季度
22万
44万
66万
我是第2季度
77万
55万
66万
我是第3季度
60万
48万
50万
我是第4季度
70万
58万
66万
全年销售总额为：682万