Java

配置环境

系统环境变量设置

官方技术文档地址

IDEA 设置问题

在Project Structure中

• 需要在Project指定Project SDK，和文件编译输出路径
• 需要在Modules哪些可以标记为源码，仅被标记为源码的路径下右键可创建Java类文件

基础概述

HelloWorld

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

**注意文件名和类名需要保持一致

基础

注释

单行注释

//单行注释

多行注释

/*
	多行注释
*/

文档注释

/**
	文档注释
*/

**常用快捷键

变量

• 需要先声明才能使用，
• 变量作用范围是当前代码块，同一个范围内不能重复声明同一个变量，
• 输出前需要给变量赋值。

ASCII表

数据类型

**整数、浮点数在赋值时，需要在值后标记，不标记赋值为默认类型

标识符和关键字

• 标志符由数字、字母、下划线（_）和美元（$）等组成
• 不能以数字开头、不能是关键字、区分大小写
• 标识符和类名遵守标识符规范，最好全英文，满足“驼峰模式”。

类型转换

自动类型转换

取值范围小类型的变量，可直接赋值给范围大的变量

**表达式中最终结果类型由表达式中最高类型决定

**表达式中，byte、short、char是直接（默认）转换为int类型参与运算。

强制类型转换

赋值时在变量前标注类型

//强制类型转换
public class Demo{
    public static void main(String[] args){
        int a =1500;
        byte b = (byte)a;
        System.out.println("HellWorld");
    }
}
//运行结果为-36

• 强制换算超过取值范围会溢出
• 浮点型强制转换整型，会直接丢弃小数部分，保留整数部分返回。

运算符

基本运算符

**默认运算均为int类型

数据拆分案例

//拆分3位数，个位、十位、百位分别输出
public class Demo{
    public static void main(String[] args){
        int data =567;
        int gewei= data % 10 ;
        int shiwei = data / 10 % 10;
        int baiwei = data / 100;
        System.out.println(shiwei);
        System.out.println(gewei);
        System.out.println(baiwei);
    }
}

加符号作为连接运算符

字符串参与运算时，加号为拼接符，其余参与运算符。

自增自减运算符

自增自减运算符参与运算时放在变量前先自增自减再赋值，在后先赋值再自增自减。

//代码代换
public class Demo{
    public static void main(String[] args){
        int a = 10;
        int b = ++a; 
        /*
        int a = 10;
        a = a + 1;
        int b = a;
        */
        int c = 10;
        int d = c++;
        /*
        int c = 10;
        int d = c;
        c = c + 1;
        */
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);
    }  
}

赋值运算符

扩展赋值运算符

关系运算符

关系运算符为条件判断，成立为true，不成立为false，输出结果为Boolean类型。

逻辑运算符

三元运算符

格式：条件表达式 ？值1 :值2；条件表达式为true返回值1，false返回值2，

//判断两值是否相等
//代码代换
public class Demo{
    public static void main(String[] args){
        int a=2,b=2;
        String c;
        c = a == b ? "相等" : "不等";
        /*
        int a=2,b=2;
        String c;
        boolean d;
        d = a == b;
        if (d == true) {
            c = "相等";
        }else {
            c ="不等";
        }
	   */
        System.out.println("两值" + c);
    }
}

优先级问题

API 介绍

API : Application Programming Interface应用程序编程接口；

调用导入对应包即可

//获取键盘输入内容
//判断两值是否相等
import java.util.Scanner;
public class Demo{
    public static void main(String[] args){
        int a,b;
        String c;
        Scanner Sc = new Scanner(System.in);
        System.out.println("输入一个数个数");
        a = Sc.nextInt();
        System.out.println("输入下一个数");
        b = Sc.nextInt();
        c = a == b ? "相等" : "不等";
        System.out.println("两值" + c);
    }
}

程序流程控制

分支结构

if

//if格式
public class Demo{
    public static void main(String[] args){
        /*true时执行后方代码块，false则跳过，执行一个代码块后结束，
        if (条件表达式) {
        	语句体1;//
        }else if(条件表达式) {
        	语句体2;
        }
        	...
        else{
        	语句体n+1;
        }
        */
    }
}

switch、switch穿透性

//switch格式
public class Demo{
    public static void main(String[] args){
        /*表达式匹配执行对应代码块，无匹配执行default代码块。
        switch (表达式) {
        	case 值1:
        		执行代码1;
        		break;
        	case 值2:
        		执行代码1;
        		break;
        	...
         	case 值n-1:
        		执行代码n-1;
        		break;            
        	default:
        		执行代码n;       		
        }
        */
    }
}

**当switch中case不写break会穿透，实现多值执行一个代码段，消除代码冗余。

循环结构

for循环

//for循环格式
import java.util.Scanner;
public class Demo{
    public static void main(String[] args){
        /*满足条件执行循环语句，不满足结束循环体
        for (初始化语句 ；循环条件 ；迭代语句) {
        	循环语句;
        }
        */
        //循环a次，a通过键盘输入。
        Scanner Sc = new Scanner(System.in);
        System.out.println("循环几次？");
        int a = Sc.nextInt();
        int a = 3;
        for (int i = 0; i < a; i++){
        	System.out.println("hello world");
        }
    }
}

while循环

//while循环
import java.util.Scanner;
public class Demo{
    public static void main(String[] args){
        /*满足条件执行循环语句，不满足结束循环体
        初始化语句;
        while (循环条件){
        	循环语句;
        	迭代语句；
        }
        */
        //循环a次，a通过键盘输入。
        Scanner Sc = new Scanner(System.in);
        System.out.println("循环几次？");
        int a = Sc.nextInt();
        int i = 0;
        while (i < a){
            System.out.println("hello world");
            i++;
        }
    }
}

do-while循环

//do-while循环
import java.util.Scanner;
public class Demo{
    public static void main(String[] args){
        /*先执行语句再判断是否进行循环
        初始化语句;
        do {
        	循环语句;
        	迭代语句；
        } while (循环条件);
        */
        //循环a次，a通过键盘输入。
        Scanner Sc = new Scanner(System.in);
        System.out.println("循环几次？（默认一次）");
        int a = Sc.nextInt();
        int i = 0;
        do {
            System.out.println("hello world");
            i++;
        } while (i < a);
    }
}

**break; 结束当前所在循环执行。（只能在switch和循环中使用，不能单独用于if）

//break循环
import java.util.Scanner;
public class Demo{
    public static void main(String[] args){
        //循环a次，a通过键盘输入。
        Scanner Sc = new Scanner(System.in);
        System.out.println("循环几次？最大为5次");
        int a = Sc.nextInt();
        int i = 1;
        while (i <= a){
            System.out.println("这是第" + i + "次重复hello world");
            i++;
            if ( i == 5) {
                break;
            }
        }
    }
}

**continue; 跳出当前循环的当次循环，进入下一次循环。

//continue循环
import java.util.Scanner;
public class Demo{
    public static void main(String[] args){
        //循环a次，a通过键盘输入。
        Scanner Sc = new Scanner(System.in);
        System.out.println("循环几次？拒绝打印第5次");
        int a = Sc.nextInt();
        int i = 0;
        while (i <= a){
            i++;
            if ( i == 5) {
                continue;
            }
            System.out.println("这是第" + i + "次重复hello world");
        }
    }
}

随机数Random

//生成a组b长度的数字
import java.util.Random;
import java.util.Scanner;
public class Demo{
    public static void main(String[] args){
        Random Number = new Random();
        //a通过键盘输入。
        Scanner Sc = new Scanner(System.in);
        System.out.println("生成几组随机密码？");
        int a = Sc.nextInt();
        System.out.println("每组密码几位数？");
        int b = Sc.nextInt();
        for (int i = 0; i <= a; i++){
            for (int j = 1; j <= b; j++){
                int data = Number.nextInt( 10) ;
                System.out.print(data);
            }
            System.out.println();
        }
    }
}

数组Array

数组定义，访问，注意事项

数组是用来存储一批同种类型数据的内存区域

静态初始化数组

定义

//完整格式
/*
数据类型[] 数组名 = new 数组类型[]{元素1,元素2,元素3,...};
 */
//简化格式
/*
数据类型[] 数组名 ={元素1,元素2,元素3,...};
 */

访问

//数组首位元素编号从0开始
//取值
System.out.println(arr[0]);
//赋值
arr[2] = 1 ;
System.out.println(arr[2]);
//获取数组的长度，数组的元素个数
System.out.println(arr.length);

**数组一但定义长度、类型就固定，访问超出最大个数位置，会报数组索引越界异常错误

**类型定义后，数组内不能存放其他类型数据

动态初始化数组

定义

/*
数据类型[] 数组名 = new 数组类型[长度];
*/
int[] arr = new int[10];

元素默认值

*两种初始化格式严格独立，不可混用

数组的遍历

格式

格式
for ( int i = 0; i < array.length ; i++ ){//遍历快捷键-数组名.fori
	a = array[i] +a ;
}

//求a个数的平均数，a通过键盘输入。
import java.util.Scanner;
public class Demo{
    public static void main(String[] args){
        //创建数组，并将每个数存入数组
        Scanner Sc = new Scanner(System.in);
        System.out.println("求几个数的平均数？");
        int a = Sc.nextInt();
        System.out.println("输入所有数字，回车间隔");
        int[] array = new int[ a ];
        for (int i = 0; i < a; i++ ) {
            int b = Sc.nextInt();
            array[i] = b ;
        }
       
        //计算数组所有元素的平均数
        System.out.println("平均数："); 
        double c = 0;
        for ( int i = 0; i < array.length ; i++ ){//遍历快捷键-数组名.fori
            c = array[i] + c ;
        }
        /*代码代换
        double c = 0;
        for (int value : array) {
        	c = value + c;
        }
        */
        c = c / array.length;
        System.out.println(c);
        //遍历数组取出最高值
        System.out.println("最大值为：");  
        int d = array[0];
        for ( int i = 0; i < array.length ; i++ ){
            if ( d < array[i]){
                d = array[i];
            }
        }
        System.out.println(d);  

    }
}

冒泡排序

每次从数组中找出最大值，最大的元素向后移动

import java.util.Scanner;
public class Demo{
    public static void main(String[] args){
        //创建数组，并将每个数存入数组
        Scanner Sc = new Scanner(System.in);
        System.out.println("几个数排序？");
        int a = Sc.nextInt();
        System.out.println("输入所有数字，回车间隔");
        int[] array = new int[ a ];
        for (int i = 0; i < a; i++ ) {
            int b = Sc.nextInt();
            array[i] = b ;
        }

        //冒泡排序
        for (int i = 0; i < array.length - 1; i++) {
            for (int j = 0; j < array.length - i - 1; j++) {
                if (array[j] > array[j+1]){
                    int temp = array[j+1];
                    array[j+1] = array [j];
                    array[j] = temp;
                }
            }
        }
        //遍历输出数组中元素
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + "\t");
        }
    }
}

数组与内存的存储的关系

数组内容是存在堆内存内，数组变量中存储的是内容的类型和内存地址

**访问超出最大索引时，会报数组索引越界异常错误ArraylndexOutOfBoundsException，程序会在越界处报错结束。

**如果数组变量中没有存储数组的地址，而是null,在访问数组信息时会出现NullPointerException(空指针异常)

Debug工具

启用断点后可逐行执行代码

方法Method

方法的定义

/*方法格式
修饰符 返回值类型 方法名(形参列表){
	方法体代码（需要执行的代码）
	return 返回值;
}
*/
//示例,加法器
public static int add (int a, int b ){
    int c = a + b;
    return c;
}
//调用 方法名(传入参数)
	int data = add( 10 , 20 );

**无返回值，无参数方法调用

public static void 方法名(){
	System.out.print("hello world!");
}

**方法与方法直接是平行关系，不能嵌套定义

**方法的返回类型为void时，方法内不能使用return返回数据，如果方法的返回值写了具体类型，防范内部必须使用return对应的类型数据

**return语句下方代码不执行，属于无效代码；

**方法不调用时不执行，调用时必须严格匹配方法的参数情况；

**方法返回值可以定义变量接收，也可以直接输出调用，无返回值方法只能直接调用。

方法的内存原理

** 方法在栈内存运行，方法先进后出

方法参数传递机制

基本类型的参数传递

传输实参给形参时，不是传输实参变量本身，而是将实参变量中储存的值，这就是值传递。

**实参：方法内部定义的变量

**形参定义方法时，"()"中声明的参数

引用类型的参数传递

引用传递时，传递的是引用的堆内存地址

方法重载

同一个类中，出现多个方法名称相同，但是形参列表不同，那么这些方法就是方法重载。

**只要时同一个类中，方法名称相同，形参列表不同，即是方法重载（不考虑如：修饰符，返回值类型等）

**形参列表不同指的是形参的个数、类型、顺序不同，不是形参的名称

return关键字

当单独在时，可以跳出当前执行的方法，并直接结束该方法。

案例

随机密码生成

业务需求：需要根据键盘键入数据确定生成几组多长的随机字符串

package src;
//求a个数的平均数，a通过键盘输入。
import java.util.Random;
import java.util.Scanner;

public class Demo {
    public static void main(String[] args) {
        //创建数组，并将每个数存入数组
        Scanner Sc = new Scanner(System.in);
        System.out.println("随机几位密码？");
        int a = Sc.nextInt();
        System.out.println("随机几组？");
        int b = Sc.nextInt();
        for (int i = 0; i < b ; i++) {
            System.out.println(Randombytes(a));
        }
    }
	//生成一组随机字符
    public static String Randombytes(int HowLong) {
        Random RandomNumber = new Random();
        String Codes = "";
        for (int i = 0; i < HowLong; i++) {
            int type = RandomNumber.nextInt(3);
            switch (type) {
                case 0:
                    char ch = (char) (RandomNumber.nextInt(26) + 65);//随机出一个大写字母
                    Codes += ch;
                    break;
                case 1:
                    char ch1 = (char) (RandomNumber.nextInt(26) + 97);//随机出一个小写字母
                    Codes += ch1;
                    break;
                case 2:
                    Codes += RandomNumber.nextInt(10);//随机出一位阿拉伯数字
                    break;
            }
        }
        return Codes;
    }
}

数组的复制

public static void CopyArrs(int[] arr1,int[] arr2){
    for (int i = 0; i < arr1.length; i++) {
		arr2[i] = arr1[i];
    }
}

双色球系统开发

业务需求：生成一组7位随机数，组内数据不重复，和一个单独数

import java.util.Random;
public class Demo {
    public static void main(String[] args) {
        //输出一组双色球彩票
        System.out.println("本次双色球号码为：");
        for (int i = 0; i < 6; i++) {
            System.out.print(CreateLuckNumbers(6) [i] +"\t");
        }
        System.out.println();
        System.out.println("幸运号码是：");
        Random RandomNumber = new Random();
        int RN = RandomNumber.nextInt(33) + 1;
        System.out.println(RN);
    }
//生成一个HowLong长度的双色球数
    public static int [] CreateLuckNumbers(int HowLong) {
        Random RandomNumber = new Random();
        int[] arr = new int[HowLong];
        for (int i = 0; i < arr.length; i++) {
            int RN = RandomNumber.nextInt(33) + 1;
            boolean flag =true;
            for (int j = 0; j < arr.length; j++) {
                if (arr[j] == RN){
                    flag =false;
                    i -= 1;
                    break;
                }
            }
            if (flag){
                arr [i] = RN;
            }
        }
        return arr;
    }
}

面向对象编程基础Object Oriented Programming

概述

需要创建一个东西后再进行编程，这个东西就是对象

设计对象、注意事项

**先设计类才能创建对象并使用

类：是对象的共同特征的描述。

对象：是真实存在的具体实例。

//设计类
public class 类名 {
	1.成员变量（代表属性，一般是名词）
	2.成员方法（代表行为，一般是动词）
	3.构造器
	4.代码块
	5.内部类   
}
//如何创建类
类名 对象名 = new 类名();
//使用对象
	//访问属性
	对象名.成员变量；
	//访问行为
	对象名.方法名(...)；

**类名首字母大写，满足“驼峰模式”，不能用关键字，必须是合法标识符，且有意义

**一个Java文件可以定义多个class类，但是只能有一个是public修饰，且public修饰的类名必须为文件名

**成员变量完整定义格式是：修饰符 数据类型 变量名 = 初始化值；

一般无需指定初始化值，默认规则为

内存机制

**对象存在于堆内存中，创建引用时，变量名内存储的时对象在堆内存中的地址

垃圾回收机制

当堆内存中引用对象不存在任何内存引用它时（栈内存引用这个对象的变量引用地址设置为null），Java会自动清除堆内存地址内数据.

int[] arr = new int [10];//在堆内存中创建一个长度为10的数组空间，引用为arr
arr = null;//arr堆内存引用地址设置为null；Java会自动释放堆该地址内存

构造器Constructor

//创建构造器
修饰符 类名(形参列表){
    ...
}

//调用构造器
类名 变量名称 = new 构造器;

**无参数构造器初始化时，成员变量数据均采用默认值

**有参数构造器在初始化对象时，同时接受参数为对象进行赋值

**一个类中默认自带无参数构造器，一但定义有参数构造器，无参数构造器就不存在了，如果还想使用无参数构造器，需要单独手写一个

this关键字

**this可用于构造器，方法中，代表当前对象地址。

this.变量名//引用当前构造器中的变量值

封装

private//私有修饰词，修饰的变量只能在本类中，不能在其他类中被引用和赋值
public//修饰的setter和getter方法来获取值和赋值    

标准JavaBean

即为实体类，其对象可以用于在程序中封装数据

** 成员变量必须使用private修饰

**提供成员变量的对应的getter /setter方法

**必须提供一个无参构造器，（有参构造器可有可无）

常用API

String

String被称为不可变字符串类型，他的对象创建后不可被更改

**运算时只是定义的String变量储存的引用地址发生变化，指向新的字符串储存地址，以""方式直接给出的字符串对象，在字符串常量池中储存，而且相同的值储存一次

**通过构造器new出来的对象，每new一次都会产生一个新对象存在堆内存中

**String进行比较时使用equias方法进行比较，只要内容一致即返回true（String变量名.equias(要比较的String变量名)）

        String a1 = "我";
        String a2 = "爱";
        String a3 = "中";
        String a4 = "国";
        String a5 = "我爱中国";
        String a6 =  a1 + a2 + a3 + a4;
        System.out.println(a6);
        System.out.println(a5 ==a6);//false,比较两个字符串变量的引用地址
        System.out.println(a5.equals(a6));//ture

String常用API

String案例

验证码

//用字符串遍历法设计一个验证码生成器
import java.util.Random;
import java.util.Scanner;
public class Demo {
    public static void main(String[] args) {
        Scanner Sc = new Scanner(System.in);
        System.out.println("取多长的字符串？");
        int a = Sc.nextInt();
        System.out.println(CAPTCHA(a));
    }

    //生成一个包含0-9，a-z,A-Z的HowLong长度的验证码
    public static String CAPTCHA(int HowLong) {
        String db = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
        Random r =new Random();
        String codes = "";
        int a = HowLong;
        for (int i = 0; i < a; i++) {
            int index =r.nextInt(db.length());//获取字符串长度，并随机出比长度小的值index
            char c = db.charAt(index);//获取index位置的字符
            codes += c;
        }
        return codes;
    }
}

ArrayList

集合长度不固定，启动后可以动态变化，类型也可以选择不固定，

ArrayList常见功能

创建一个ArrayList对象

	ArrayList list = new ArrayList()

添加元素

	list.add("Java");
	list.add("MySQL");
	list.add("中国");

指定索引位置插入元素(指定位置开始元素后移)

	list.add(1,"世界");
	System.out.println(list);

ArrayList对泛型的支持

ArrayList为泛型类，可在编译阶段约束集合内对象只能操作某种数据类型

	ArrayList<String>//只操作字符串类型的元素
    ArrayList<Integer>//只操作整数类型的元素

集合只能存储引用类型，不支持基本类型（int和Integer是存在区别的，集合中不可使用int类型）

**默认泛型为String，如果希望所有数据类型都支持，泛型要标注为Object。

ArrayList常用API

import java.util.ArrayList;
public class Demo {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList();
        list.add("Java");
        list.add("Java");
        list.add("MySQL");
        list.add("MyBatis");
        list.add("Html");
        //1.获取某个索引处的元素值
        System.out.println(list);
        System.out.println(list.get(2));
        //2.获取集合的大小
        System.out.println(list.size());
        //3.删除某个索引处的元素，并返回这个元素
        System.out.println(list.remove(0));
        System.out.println(list);
        //4.删除指定某个元素，返回是是否删除成功，如果有多个元素，默认删除索引值小的
        System.out.println(list.remove("Java"));
        //5.集合遍历
        for (int i = 0; i <list.size() ; i++) {
            System.out.println(list.get(i));
        }
        	//一般使用倒着遍历,避免寻址溢出
        	for (int i = list.size() - 1; i >= 0 ; i--) {
                System.out.println(list.get(i));
            }
        //修改索引处的元素返回被修改的元素
        System.out.println(list.set(0, "if"));
    }
}

案例

Java的简单的ATM系统实现