JAVA语言基础学习笔记

安装：

JDK：Java虚拟机，运行Java的环境，开发Java所必须的命令工具。
IDEA：
JetBrains公司的，有免费版，有收费的（可破解）

基础：

变量：就是存数的
声明：

int a; //声明一个整型的变量，名为a
int b,c,d; //声明三个整型的变量，名为b,c,d
//int a; //编译错误，变量不能同名

初始化：第一次赋值---------相当于给帐户存钱

int a = 250; //声明整型变量a并赋值为250
int b;   //声明整型变量b
b = 250; //给变量b赋值为250
b = 360; //修改变量b的值为360
int c=5,d=10; //声明两个整型变量c和d，并分别赋值为5和10

使用：---------使用的是帐户里面的钱

对变量的使用就是对它所存的那个数的使用

int a = 5;
int b = a+10; //取出a的值5，加10后，再赋值给变量b
System.out.println(b);   //输出变量b的值15
System.out.println("b"); //输出b，双引号中的原样输出
a = a+10; //在a本身基础之上增10
int c = 5000; //帐户余额
c = c-1000; //取款1000

变量在用之前必须声明并初始化

//System.out.println(m); //编译错误，变量m未声明
int m;
//System.out.println(m); //编译错误，变量m未初始化

命名：
只能包含字母、数字、_和$符，并且不能以数字开头
严格区分大小写
不能使用关键字
允许中文命名，但不建议，建议"英文的见名知意"、“小驼峰命名法”

int a_5$,_3c,$_;
//int a*b; //编译错误，不能包含*号等特殊符号
//int 1a; //编译错误，不能以数字开头
int aa = 5;
//System.out.println(aA); //编译错误，严格区分大小写
//int class; //编译错误，不能使用关键字

int 年龄; //允许，但不建议
int age; //建议"英文见名知意"
int score,myScore,myJavaScore; //建议"小驼峰命名法"

八种基本数据类型：byte,short,int,long,float,double,boolean,char

int：整型，4个字节，-21个多亿到21个多亿

整数直接量默认为int类型，但不能超范围，若超范围则发生编译错误
两个整数相除，结果还是整数，小数位无条件舍弃(不会四舍五入)
整数运算时，若超出int范围则发生溢出(溢出不是错误，但需要避免)

//1)int:整型，4个字节，-21个多亿到21个多亿
int a = 25; //25称为整数直接量，默认int类型
//int b = 10000000000; //编译错误，100亿默认为int类型，但超出int范围了
//int c = 3.14; //编译错误，整型变量中只能装整数
System.out.println(5/2); //2
System.out.println(2/5); //0
System.out.println(5/2.0); //2.5
int d = 2147483647; //int的最大值
d = d+1;
System.out.println(d); //-2147483648(int最小值)，发生溢出了，溢出是需要避免的

long：长整型，8个字节，很大很大很大

长整型直接量需在数字后加L或l
运算时若有可能溢出，建议在第1个数字后加L

//2)long:长整型，8个字节，很大很大很大
long a = 25L; //25L为长整型直接量
//long b = 10000000000; //编译错误，100亿默认为int类型，但超出int范围了
long c = 10000000000L; //100L为长整型直接量
//long d = 3.14; //编译错误，长整型变量只能装整数

//运算时若有可能溢出，建议在第1个数字后加L
long e = 1000000000*2*10L;
System.out.println(e); //200亿
long f = 1000000000*3*10L;
System.out.println(f); //不是300亿
long g = 1000000000L*3*10;
System.out.println(g); //300亿

double：浮点型，8个字节，很大很大很大

浮点数直接量默认为double型，若想表示float需在数字后加F或f
double与float型数据参与运算时，有可能会出现舍入误差，精确场合不能使用

//3)double:浮点型，8个字节，很大很大很大
double a = 3.14; //3.14为浮点数直接量，默认double型
float b = 3.14F; //3.14F为float型直接量
double c = 1234000000000000000000000000000000.0;
System.out.println(c); //1.234E33，科学计数法表示，相当于1.234*(10的33次幂)

double d=3.0,e=2.9;
System.out.println(d-e); //0.10000000000000009，有可能会发生舍入误差，精确场合不能使用

boolean：布尔型，1个字节

只能赋值为true或false

//4)boolean:布尔型，1个字节
boolean a = true;  //true为布尔型直接量-----真
boolean b = false; //false为布尔型直接量----假
//boolean c = 250; //编译错误，布尔型只能赋值为true或false

char：字符型，2个字节

采用Unicode字符集编码格式，一个字符对应一个码

表现的形式是字符char，但本质上是码int(0到65535之间)

ASCII码：‘a’—97 ‘A’—65 ‘0’—48

字符型直接量必须放在单引号中，并且只能有1个

特殊符号需通过\来转义

//5)char:字符型，2个字节
char c1 = '女'; //字符女
char c2 = 'f';  //字符f
char c3 = '6';  //字符6
char c4 = ' ';  //空格符
//char c5 = 女; //编译错误，字符型直接量必须放在单引号中
//char c6 = ''; //编译错误，必须有字符
//char c7 = '女性'; //编译错误，只能有1个字符

char c8 = 65; //0到65535之间
System.out.println(c8); //println输出时会依据c8的数据类型显示
//若c8为char型，则显示字符
//若c8为int型，则显示数字
char c9 = '\\';
System.out.println(c9); //\

类型间的转换：

基本类型由小到大依次为：

   byte----short----int----long----float----double

                  char----

两种方式：

自动/隐式类型转换：小类型到大类型

强制类型转换：大类型到小类型

语法：(要转换成为的数据类型)变量

强转有可能溢出或丢失精度

//类型间的转换:
int a = 5;
long b = a; //自动类型转换
int c = (int)b; //强制类型转换

long d = 5;   //自动类型转换
double e = 5; //自动类型转换

long f = 10000000000L;
int g = (int)f; //强制类型转换
System.out.println(g); //1410065408，强转有可能发生溢出
double h = 25.987;
int i = (int)h; //强制类型转换
System.out.println(i); //25，强转有可能丢失精度

两点规则：

整数直接量可以直接赋值给byte,short,char，但不能超出范围
byte,short,char型数据参与运算时，系统一律自动将其转换为int再运算

byte b1 = 5; //byte的范围为-128到127之间
byte b2 = 6;
byte b3 = (byte)(b1+b2);

System.out.println(2+2);     //4
System.out.println(2+'2');   //52，2加上'2'的码50
System.out.println('2'+'2'); //100，'2'的码50，加上'2'的码50

运算符：运算的符号

算术：+，-，*，/，%，++，–

%:取模/取余，余数为0即为整除

++/–：自增1/自减1，可在变量前也可在变量后

单独使用时，在前在后都一样

被使用时，在前在后不一样

a++的值为a--------(a–的值为a)
++a的值为a+1------(–a的值为a-1)

//%的演示
System.out.println(8%2); //0，商4余0----整除
System.out.println(5%2); //1，商2余1
System.out.println(2%8); //2，商0余2

//++单独使用:
int a=5,b=5;
a++; //相当于a=a+1
++b; //相当于b=b+1
System.out.println(a); //6
System.out.println(b); //6

//++被使用:
int a=5,b=5;
int c = a++; //1)保存a++的值5  2)a自增1变为6  3)将第1步保存的值5赋值给c--底层运算过程
//---粗暴记法:a++的值为5，c就是5
int d = ++b; //1)保存++b的值6  2)b自增1变为6  3)将第1步保存的值6赋值给d--底层运算过程
//---粗暴记法:++b的值为6，d就是6
System.out.println(a); //6
System.out.println(b); //6
System.out.println(c); //5
System.out.println(d); //6

//--单独使用:
int a=5,b=5;
a--; //相当于a=a-1
--b; //相当于b=b-1
System.out.println(a); //4
System.out.println(b); //4

//--被使用:
int a=5,b=5;
int c = a--; //a--的值为5，所以c的值为5
int d = --b; //--b的值为4，所以d的值为4
System.out.println(a); //4
System.out.println(b); //4
System.out.println(c); //5
System.out.println(d); //4

关系：>，<，>=，<=，==，!=

关系运算的结果为boolean型，
关系成立则为true，关系不成立则为false

int a=5,b=10,c=5;
boolean b1 = a>b;
System.out.println(b1);   //false
System.out.println(c<b);  //true
System.out.println(a>=c); //true
System.out.println(a<=b); //true
System.out.println(a==c); //true
System.out.println(a!=c); //false

System.out.println(a+c>b);  //false
System.out.println(a%2==0); //false
System.out.println(c++>5);  //false-------c自增1变为6
System.out.println(c++>5);  //true--------c自增1变为7

逻辑：&&，||，!

&&：短路与(并且)，两边都为真则为真，见false则false

当第1个条件为false时，发生短路(后面的不执行了)

||：短路或(或者)，有真则为真，见true则true

当第1个条件为true时，发生短路(后面的不执行了)

!：逻辑非(取反)，非真则假，非假则真

int a=5,b=10,c=5;
//&&的演示:
boolean b1 = b>=a && b<c;
System.out.println(b1);          //true&&false=false
System.out.println(b<=c && b>a); //false&&true=false
System.out.println(a==b && c>b); //false&&false=false
System.out.println(b!=c && a<b); //true&&true=true
int age = 25;
System.out.println(age>=18 && age<=50); //看age是否在18到50之间

//||的演示:
System.out.println(b>=a || b<c); //true||false=true
System.out.println(b<=c || b>a); //false||true=true
System.out.println(b!=c || a<b); //true||true=true
System.out.println(a==b || c>b); //false||false=false
int score = 89;
System.out.println(score<0 || score>100); //看score是否不合法

//!的演示
boolean b2 = !(a<b);
System.out.println(b2);     //!true=false
System.out.println(!(a>b)); //!false=true

//短路的演示
int a=5,b=10,c=5;
boolean b3 = a>b && c++>2;
System.out.println(b3); //false
System.out.println(c);  //5，发生短路了

boolean b4 = a<b || c++>2;
System.out.println(b4); //true
System.out.println(c);  //5，发生短路了

赋值：=，+=，-=，*=，/=，%=

简单赋值运算符：=

扩展赋值运算符：+=，-=，*=，/=，%=

注：扩展赋值自带强转功能

int a = 5;
a += 10; //相当于a=(int)(a+10)
System.out.println(a); //15
a *= 2; //相当于a=(int)(a*2)
System.out.println(a); //30
a /= 6; //相当于a=(int)(a/6)
System.out.println(a); //5

//小面试题:
short s = 5;
//s = s+10; //编译错误，需强转: s=(short)(s+10);
s += 10; //相当于s=(short)(s+10)

字符串连接：+

+：

若两边为数字，则做加法运算
若两边出现了字符串，则做字符串连接
任何类型与字符串相连，结果都会变为字符串类型----同化作用

//字符串拼接演示
int age = 38;
System.out.println("age="); //age=
System.out.println(age);    //38
System.out.println("age="+age); //age=38
System.out.println("我的年龄是"+age); //我的年龄是38
System.out.println("我今年"+age+"岁了"); //我今年38岁了

String name = "WKJ";
System.out.println("name="+name); //name=WKJ
System.out.println("大家好，我叫"+name); //大家好，我叫WKJ
System.out.println("大家好，我叫"+name+"，今年"+age+"岁了"); //大家好，我叫WKJ，今年38岁了

//同化作用演示
System.out.println(10+20+30+""); //60---------String
System.out.println(10+20+""+30); //3030-------String
System.out.println(""+10+20+30); //102030-----String

条件/三目：?:

语法：

boolean?数1:数2

执行过程：

注：整个表达式是有值的，它的值要么是?号后的数1，要么是:号后的数2

计算boolean的值：

若为true，则整个表达式的值为?号后的数1
若为false，则整个表达式的值为:号后的数2

int num = 5;
int flag = num>0?1:-1;
System.out.println(flag); //1

int a=8,b=55;
int max = a>b?a:b;
System.out.println("max="+max);

分支结构：基于条件执行某语句

if结构：1条路

语法：

   if(boolean){
         语句块
    }   

执行过程：

判断boolean的值:
     若为true，则执行语句块1(if整个结束)
     若为false，则if直接结束

//1)偶数的判断:
int num = 5;  //带数(6,5)
if(num%2==0){
    System.out.println(num+"是偶数");
}
System.out.println("继续执行...");

//2)满500打8折:
double price = 300.0; //消费金额  带数(600.0,300.0)
if(price>=500){ //满500
    price *= 0.8; //打8折
}
System.out.println("最终结算金额为:"+price);

//3)判断年龄是否在18到50之间，若满足则输出:"满足条件"
int age = 88;  //带数(25,5,88)
if(age>=18 && age<=50){
    System.out.println("年龄满足条件");
}
System.out.println("继续执行...");

if…else结构：2条路

语法：

if(boolean){
     语句块1
}else{
     语句块2
}

执行过程：

判断boolean的值:
     若为true，则执行语句块1(整个结束)
     若为false，则执行语句块2(整个结束)

说明：

语句块1和语句块2，必走其中之一------------2选1

//1)偶数、奇数的判断:
int num = 5;  //带数(6,5)
if(num%2==0){
    System.out.println(num+"是偶数");
}else{
    System.out.println(num+"是奇数");
}
System.out.println("继续执行...");

//2)满500打8折，不满500打9折:
double price = 300.0;  //带数(600.0,300.0)
if(price>=500){ //满500
    price *= 0.8;
}else{ //不满500
    price *= 0.9;
}
System.out.println("最终结算金额为:"+price);

//3)判断成绩是否合法，合法则输出"该成绩合法"，否则输出"该成绩不合法":
int score = 560; //带数(95,-90,560)
if(score<0 || score>100){
    System.out.println("该成绩不合法");
}else{
    System.out.println("该成绩合法");
}
System.out.println("继续执行...");

Scanner接收用户输入的数据：共3步，不需要理解，先背下来

在package下：

import java.util.Scanner;

在main中：

Scanner scan = new Scanner(System.in);

在第2步之下：

System.out.println("请输入年龄:");
int age = scan.nextInt();
System.out.println("请输入商品价格:");
double price = scan.nextDouble();

package day04;
import java.util.Scanner; //1.导入一个扫描仪
//Scanner的演示
public class ScannerDemo {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in); //2.新建一个扫描仪
        System.out.println("请输入年龄:");
        int age = scan.nextInt(); //3.扫描一个整数给age
        System.out.println("请输入商品价格:");
        double price = scan.nextDouble(); //3.扫描一个小数给price
        System.out.println("年龄为:"+age+"，价格为:"+price);
    }
}

分支结构：

if…else if结构：多条路

语法：

   if(boolean-1){
     语句块1
   }else if(boolean-2){
     语句块2
   }else if(boolean-3){
     语句块3
   }else{
     语句块4
   }

执行过程：

判断boolean-1，若为true则执行语句块1(结束)，若为false则
再判断boolean-2，若为true则执行语句块2(结束)，若为false则
再判断boolean-3，若为true则执行语句块3(结束)，若为false则 执行语句块4(结束)

说明：

语句块1/2/3/4，只能执行其中之一------------多选1

public class ScoreLevel {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入成绩:");
        double score = scan.nextDouble();
//带数(-25,888,95,85,65,45)
        if(score<0 || score>100){
            System.out.println("成绩不合法");
        }else if(score>=90){ //合法
            System.out.println("A-优秀");
        }else if(score>=80){
            System.out.println("B-良好");
        }else if(score>=60){
            System.out.println("C-中等");
        }else{
            System.out.println("D-不及格");
        }
    }
}

switch…case结构：多条路

优点：效率高、结构清晰

缺点：只能对整数判断相等

break：跳出switch

常见面试题：switch可以作用于什么类型的数据上

-------------------------byte,short,int,char,String,枚举类型

public class CommandBySwitch {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("请选择功能: 1.取款  2.存款  3.查询余额  0.退卡");
        int command = scan.nextInt();
        switch(command){
            case 1:
                System.out.println("取款操作...");
                break;
            case 2:
                System.out.println("存款操作...");
                break;
            case 3:
                System.out.println("查询余额操作...");
                break;
            case 0:
                System.out.println("退卡操作...");
                break;
            default:
                System.out.println("输入错误");
        }
    }
}

循环：反复多次执行一段相同或相似的代码

循环三要素：

循环变量的初始化

循环的条件(以循环变量为基础)

循环变量的改变(向着循环的结束变)

循环变量：在整个循环过程中所反复改变的那个数

//跑3圈:
循环变量:所跑圈数count
1)int count=0;
2)count<3
3)count++;
  count=0/1/2/ 3时结束

圈数为0
够3圈吗？ 不够 跑一圈 圈数为1
够3圈吗？ 不够 跑一圈 圈数为2
够3圈吗？ 不够 跑一圈 圈数为3
够3圈吗？ 够了

//打印机打印6份简历:
循环变量:所打份数num
1)int num=0;
2)num<6
3)num++;
  num=0/1/2/3/4/5/ 6时结束

份数为0
够6份吗？ 不够 打印一份 份数为1
够6份吗？ 不够 打印一份 份数为2
够6份吗？ 不够 打印一份 份数为3
够6份吗？ 不够 打印一份 份数为4
够6份吗？ 不够 打印一份 份数为5
够6份吗？ 不够 打印一份 份数为6
够6份吗？ 够了
循环结构：

while结构：先判断后执行，有可能一次都不执行

语法：

while(boolean){
语句块-------------反复执行的代码
}

执行过程：

判断boolean的值，若为true则执行语句块，
再判断boolean的值，若为true则再执行语句块，
再判断boolean的值，若为true则再执行语句块，
如此反复，直到boolean的值为false时，while循环结束

代码演示：

//1)输出5次"行动是成功的阶梯":
int times = 0;  //1)循环变量的初始化
while(times<5){ //2)循环的条件
    System.out.println("行动是成功的阶梯");
    times++;    //3)循环变量的改变
}
System.out.println("继续执行...");

/*
  执行过程:----带数
                times=0
    true  输出  times=1
    true  输出  times=2
    true  输出  times=3
    true  输出  times=4
    true  输出  times=5
    false while循环结束
    输出继续执行...
 */

//2)输出9的乘法表:
int num = 1;     //3*9=27
while(num<=9){
    System.out.println(num+"*9="+num*9);
    num++;  //num+=2;
}
System.out.println("继续执行...");
猜数字小游戏代码：

public class Guessing {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int num = (int)(Math.random()*1000+1); //1到1000之内的随机数
        System.out.println(num); //作弊

        //300(大),200(小),250(对)
        System.out.println("猜吧!");
        int guess = scan.nextInt(); //1.
        while(guess!=num){ //2.
            if(guess>num){
                System.out.println("太大了");
            }else{
                System.out.println("太小了");
            }
            System.out.println("猜吧!");
            guess = scan.nextInt(); //3.
        }
        System.out.println("恭喜你猜对了!");
    }
}

do…while结构：先执行后判断，至少执行一次

要素1与要素3相同时，首选do…while

语法：

  do{
     语句块
   }while(boolean);

执行过程：

先执行语句块，再判断boolean的值，若为true则
再执行语句块，再判断boolean的值，若为true则
再执行语句块，再判断boolean的值，若为true则
再执行语句块，如此反复，直到boolean的值为false，则    do...while结束

猜数字小游戏代码：

public class Guessing {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int num = (int)(Math.random()*1000+1); //1到1000之内的随机数
        System.out.println(num); //作弊

        //假设num=250
        //300(大),200(小),250(对)
        int guess;
        do{
            System.out.println("猜吧!");
            guess = scan.nextInt(); //1+3
            if(guess>num){
                System.out.println("太大了");
            }else if(guess<num){
                System.out.println("太小了");
            }else{
                System.out.println("恭喜你猜对了");
            }
        }while(guess!=num); //2
    }
}

补充：

变量的作用域/范围：

从变量的声明开始，到包含它最近的大括号结束
生成随机数：

int num = (int)(Math.random()*1000+1); //1到1000

Math.random()--------------0.0到0.9999999999999999...
*1000----------------------0.0到999.99999999999999...
+1-------------------------1.0到1000.9999999999999...
(int)----------------------1到1000

任何复杂的程序逻辑都可以通过三种结构来实现：

顺序结构：从上往下逐行执行，每句必走
分支结构：有条件的执行某语句一次，并非每句必走
循环结构：有条件的执行某语句多次，并非每句必走
循环结构：

for结构：应用率高、与次数相关的循环

语法：

 //     1   2   3
 for(要素1;要素2;要素3){
        语句块/循环体----------------反复执行的代码    4
   }

执行过程：
1243243243243243243…2

代码演示：

//for循环中的循环变量i，作用域仅在当前for中
for(int i=1;i<=9;i++){
    System.out.println(i+"*9="+i*9);
}
for(int i=1;i<=9;i+=2){
    System.out.println(i+"*9="+i*9);
}
for(int i=9;i>=1;i--){
    System.out.println(i+"*9="+i*9);
}

for(int times=0;times<5;times++){
    System.out.println("行动是成功的阶梯");
}
System.out.println("继续执行...");
/*
执行过程:
times=0  true  输出
    times=1  true  输出
    times=2  true  输出
    times=3  true  输出
    times=4  true  输出
    times=5  false for循环结束
    输出继续执行...
*/

//for的特殊格式:----------了解
int i=1;
for(;i<=9;i++){
    System.out.println(i+"*9="+i*9);
}
for(int i=1;i<=9;){
    System.out.println(i+"*9="+i*9);
    i++;
}
for(;;){ //没有条件的循环就是一个死循环
    System.out.println("我要学习...");
}

for(int i=1,j=5;i<=5;i+=2,j-=2){
}
/*
  i=1,j=5  true
  i=3,j=3  true
  i=5,j=1  true
  i=7,j=-1 false
 */

三种循环结构的选择规则：

先看循环是否与次数相关：

若相关----------------------------直接上for

若无关，再看要素1与要素3是否相同：

若相同------------------------直接上do…while
若不同------------------------直接上while
break：跳出循环

for(int i=1;i<=9;i++){
    if(i==4){ //在某种特定条件下，提前结束循环
        break;
    }
    System.out.println(i+"*9="+i*9);
}
/* 
  i=1  true  1*9=9
  i=2  true  2*9=18
  i=3  true  3*9=27
  i=4  true
*/        

continue：跳过循环体中剩余语句而进入下一次循环

//输出9的乘法表，只要不能被3整除的
for(int i=1;i<=9;i++){
    if(i%3!=0){
        System.out.println(i+"*9="+i*9);
    }
}


//输出9的乘法表，跳过能被3整除的
for(int i=1;i<=9;i++){
    if(i%3==0){
        continue; //跳过循环体中剩余语句而进入下一次循环
    }
    System.out.println(i+"*9="+i*9);
}
/*
    i=1  1*9=9
    i=2  2*9=18
    i=3
    i=4  4*9=36
    i=5  5*9=45
    i=6
    i=7  7*9=63
    i=8  8*9=72
    i=9
    i=10
*/

随机加法运算器案例：

package day05;
import java.util.Scanner;
//随机加法运算器
public class Addition {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int score = 0; //总分
        for(int i=1;i<=10;i++) { //10次
            int a = (int)(Math.random()*100); //加数a，0到99之间
            int b = (int)(Math.random()*100); //加数b
            int result = a+b; //存正确答案
            System.out.println("("+i+")"+a+"+"+b+"=?"); //1)出题

            System.out.println("算吧!----输入-1可提前结束");
            int answer = scan.nextInt(); //2)答题

            if(answer==-1){ //3)判题
                break;
            }
            if(answer==result){
                System.out.println("答对了");
                score += 10; //答对1题，加10分
            }else{
                System.out.println("答错了");
            }
        }
        System.out.println("总分为:"+score);
    }
}

嵌套循环：

循环中套循环，常常多行多列时使用，一般外层控制行，内层控制列
执行过程：外层循环走一次，内层循环走所有次
建议：嵌套层数越少越好，能用一层就不用两层，能用两层就不用三层，若业务必须通过三层以上的循环才能解决，说明你的设计有问题
break只能跳出当前一层循环

for(int num=1;num<=9;num++){ //控制行
    for(int i=1;i<=num;i++){ //控制列
        System.out.print(i+"*"+num+"="+i*num+"\t");
    }
    System.out.println(); //换行
}
/*
  执行过程:
    num=3
      i=1  1*3=3
      i=2  2*3=6
      i=3  3*3=9
      i=4  false
      换行
    num=2
      i=1  1*2=2
      i=2  2*2=4
      i=3  false
      换行
    num=1
      i=1  1*1=1
      i=2  false
      换行
 */

数组：

是一种数据类型(引用类型)

相同数据类型元素的集合

定义：

//声明int型数组arr，包含10个元素，每个元素都是int型，默认值为0
int[] arr = new int[10];
初始化：给数组中的元素做初始化

int[] arr = new int[3]; //0,0,0
int[] arr = {1,4,7}; //1,4,7
int[] arr = new int[]{1,4,7}; //1,4,7
int[] arr;
//arr = {1,4,7}; //编译错误
arr = new int[]{1,4,7}; //正确

访问：访问的是数组中的元素

通过(数组名.length)可以获取数组的长度(元素的个数)

int[] arr = new int[3];
System.out.println(arr.length); //3

通过下标/索引来访问数组中的元素

下标从0开始，最大到(数组的长度-1)

int[] arr = new int[3];
arr[0] = 100; //给第1个元素赋值为100
arr[1] = 200; //给第2个元素赋值为200
arr[2] = 300; //给第3个元素赋值为300
System.out.println(arr[arr.length-1]); //输出最后一个元素的值
遍历/迭代：从头到尾挨个走一遍

int[] arr = new int[10];
for(int i=0;i<arr.length;i++){ //遍历arr数组
    //arr[i]代表arr中的每一个元素
    //给每个元素赋值为0到99之间的随机数
    arr[i] = (int)(Math.random()*100); 
    System.out.println(arr[i]); //输出每个元素的值
}

数组：

复制：

System.arraycopy(a,1,b,0,4);

//7)数组的复制:
int[] a = {10,20,30,40,50};
int[] b = new int[6]; //0,0,0,0,0,0
//a:源数组
//1:源数组的起始下标
//b:目标数组
//0:目标数组的起始下标
//4:要复制的元素个数
System.arraycopy(a,1,b,0,4); //灵活性好
for(int i=0;i<b.length;i++){
    System.out.println(b[i]);
}

int[ ] b = Arrays.copyOf(a,6);

//常规复制
int[] a = {10,20,30,40,50};
//a:源数组
//b:目标数组
//6:目标数组的长度(元素个数)
//---若目标数组长度>源数组长度，则末尾补默认值
//---若目标数组长度<源数组长度，则将末尾的截掉
int[] b = Arrays.copyOf(a,6); //灵活性差
for(int i=0;i<b.length;i++){
    System.out.println(b[i]);
}

//数组的扩容
int[] a = {10,20,30,40,50};
//数组扩容(创建了一个更大的新的数组，并将源数组数据复制进去了)
a = Arrays.copyOf(a,a.length+1);
for(int i=0;i<a.length;i++){
    System.out.println(a[i]);
}

综合案例：

package day06;
import java.util.Arrays;
//求数组元素的最大值，并将最大值放在数组最后一个元素的下一个位置
public class MaxOfArray {
    public static void main(String[] args) {
        int[] arr = new int[10];
        for(int i=0;i<arr.length;i++){
            arr[i] = (int)(Math.random()*100);
            System.out.println(arr[i]);
        }

        int max = arr[0]; //假设第1个元素为最大值
        for(int i=1;i<arr.length;i++){ //遍历剩余元素
            if(arr[i]>max){ //若剩余元素大于max
                max = arr[i]; //则修改max为较大的
            }
        }
        System.out.println("最大值为:"+max);

        arr = Arrays.copyOf(arr,arr.length+1); //扩容
        arr[arr.length-1] = max; //将最大值max赋值给arr中的最后一个元素
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }
}

排序：

Arrays.sort(arr); //升序排列(从小到大)

//8)数组的排序:
int[] arr = new int[10];
for(int i=0;i<arr.length;i++){
    arr[i] = (int)(Math.random()*100);
    System.out.println(arr[i]);
}

Arrays.sort(arr); //对arr进行升序排列

System.out.println("数组排序后的数据:");
for(int i=0;i<arr.length;i++){
    System.out.println(arr[i]);
}

System.out.println("倒序输出:");
for(int i=arr.length-1;i>=0;i--){
    System.out.println(arr[i]);
}

方法：函数、过程

封装一段特定的业务逻辑功能
尽可能的独立，一个方法只干一件事
方法可以被反复多次调用
减少代码重复，有利于代码复用，有利于代码维护
定义方法：五要素

修饰词    返回值类型   方法名(参数列表) {

     方法体--------------具体的业务逻辑功能实现

}

//无参无返回值
public static void say(){
    System.out.println("大家好，我叫WKJ，今年38岁了");
}
//有参无返回值
public static void sayHi(String name){ //---------形参
    System.out.println("大家好，我叫"+name+"，今年38岁了");
}
//有参无返回值
public static void sayHello(String name,int age){
    if(age>=35){ //在某种特定条件下，提前结束方法
        return; //结束方法
    }
    System.out.println("大家好，我叫"+name+"，今年"+age+"岁了");
}

//无参有返回值
public static double getNum(){
    //在有返回值的方法中:
    //--必须得通过return来返回一个值，并且这个值的类型必须与返回值类型匹配
    //return "abc"; //编译错误，返回的值必须与返回值类型匹配
    return 8.88; //1)结束方法的执行  2)返回一个结果给调用方
}

//有参有返回值
public static int plus(int num1,int num2){
    int num = num1+num2;
    return num; //返回的是num里面的那个数
    //return num1+num2; //返回的是num1与num2的和
}
//获取指定整型数组元素的最小值
public static int getMinOfArray(int[] arr){
    int min = arr[0]; //假设第1个元素为最小值
    for(int i=1;i<arr.length;i++){
        if(arr[i]<min){
            min = arr[i];
        }
    }
    return min;
}

调用方法：

无返回值：方法名(有参传参);
有返回值：数据类型 变量 = 方法名(有参传参);

//say();

//sayHi(); //编译错误，有参则必须传参
//sayHi(250); //编译错误，参数类型必须匹配
sayHi("zhangsan"); //String name="zhangsan" //-------实参
sayHi("lisi"); //String name="lisi" //---------------实参
sayHi("wangwu"); //String name="wangwu" //-----------实参

sayHello("zhangsan",25); //实参
sayHello("WKJ",38); //实参

double a = getNum(); //getNum()的值就是8.88
System.out.println(a); //8.88----模拟对返回值的后续操作

int b = plus(5,6);
System.out.println(b); //11----模拟对返回值的后续操作

int m=5,n=6;
int c = plus(m,n); //传递的是m和n里面的那个数
System.out.println(c); //11----模拟对返回值的后续操作

int[] arr = {13,45,1,35};
int min = getMinOfArray(arr);
System.out.println(min); //1----模拟对返回值的后续操作

int[] a = new int[10];
for(int i=0;i<a.length;i++){
    a[i] = (int)(Math.random()*100);
}
int b = getMinOfArray(a);
System.out.println(b);

return：

return 值; //1)结束方法的执行 2)返回结果给调用方

----------用在有返回值方法中

return; //1)结束方法的执行-----------------用在无返回值的方法中