Java基础

第一章

认识Java

程序是什么

1. 程序一词来自生活，通常指完成某些事情的一种既定方式和过程，可以将程序看成一系列动作执行的描述
2. 重点：程序就是一系列有序指令的集合

java的产生

1. Java是Sun Microsystems于1995年推出的高级编程语言

Java可以做什么

1. 开发桌面应用程序
2. 开发面向Internet的应用程序

Java平台的体系结构

1. Java SE 面向对象 API JVM…
2. Java ME 移动设备 游戏 通信…
3. Java EE JSP EJB服务…

开发三步骤

1. 编写源程序（编写.java）
2. 编译源程序(编译.class)
3. 运行

使用记事本开发三步骤

1：编写源代码以.java为后缀名保存     
2：使用javac命令编译.java文件生成.class文件
3：使用java命令运行.class文件。输出程序结果

java程序的结构

//外层框架
public class HelloWorld{
    //java程序入口程序
    public static void main(String[] args){
        //编写代码
        System.out.println("Hello World");
    }
}
// class：关键字    HelloWorld:类名与文件名完全一致  
//main方法四要素必不可少：public  static void  String[] args 
//main()方法是java程序执行的入口
//{}一一对应缺一不可

//public:公共的  static:静态的 void:空的/没有返回值 String[]:String类型数组

输出语句

System.out.println("Hello World"); //打印完引号中的信息会自动换行

System.out.print("Hello World"); //打印输出信息后不会自动换行

区别：有ln会自动换行，没有ln不会自动换行

转义符

• \t:制表符
• \n:换行符

java程序的注释：

单行注释以//开始
多行注释以/*开始 */结尾   
多行注释的每一行开头可以写多个或者一个*  

java的编码规范：

1. 类名使用public 修饰
2. 一行只写一条语句
3. {}的使用以及位置
4. 代码缩进

注意：

• Java对大小写敏感!
• 每一条Java语句必须以分号结束!
• 注意：不要漏写引号!并且必须是英文的！

第二章：

数据类型 变量 运算符

变量是什么

表示一个存储数据的基本空间

不同数据存入具有不同内存地址的空间，相互独立 

java常用的数据类型

整形int :用于存储整数，例如：1天   99岁

字符串String:用于存储字符串，l例如：我的爱好是打游戏

字符型char:用于存储单个字符：例如：男/女   开/关

非整形double:用于存储小数，例如0.6元，3.5小时

布尔boolean:，存储的值只有两个：true  false

如何声明变量以及使用

先声明后赋值    
String name;   name = "张三"；
边声明边赋值
Sting name ="张三";

常量

程序中运行中，不允许被修改的量使用final修饰
  例如：  final int age = 19;
优点：安全
只能被赋值一次，通常定义时即对其初始化  

变量名命名规则？

开头：字母   下划线  $符号
其余部分: 数字   字母   下划线  $符号

重点:不能使用关键字    

运算符

算数运算符：+ - * / % 

赋值运算符：=      把=右边的值或表达式结果存储到=左边的变量中

关系运算符：> < >= <= != ==

逻辑运算符：&&：并且   ||：或者  ！：取反  

运算符优先级：!>算数运算符>关系运算符>&&>||    

自动类型转换规则：

1：两种数据类型要兼容        
2：小转大 例如 double类型大于int类型

强制类型转换：

语法：（类型名）（表达式）
例如：int  b = (int)10.2;

分解一个数字个十百千：

int gewei = num % 10; 
int shiwei = num / 10 % 10; 
int baiwei = num / 100 % 10; 
int qianwei = num / 1000;

产生随机数

int random=(int)(Math.random()*10);

Scanner使用

1:用来获取用户（在控制台）的输入
2:先导入Scanner类所在的包：import java.util.Scanner;
3:创建Scanner类对象： Scanner scanner/input=new Scanner(System.in);
4:使用扫描仪对象来获取数据：
            scanner.next();--》获取字符串; 
            scanner.nextlnt();--》获取整形变量（整数）;
            scanner.nextDouble();--》获取非整型变量（小数）;
            scanner.next().charAt(0);--》获取单个字符;   

自增自减:++ –

（1）int a=num++; 表示num先赋值给a，在自加1；
（2）int b=++num; 表示num先自加1，在赋值给b；

第三章

选择结构

基本的if选择结构:可以处理单分支的if选择结构

//结果必须是布尔值
if ( 条件 ) { 
        //代码块 
}

if-else选择结构:可以处理两个分支的if选择结构

if ( 条件 ) { 
        //代码块1  
 }else { 
       //代码块2 
}

多重if选择结构:可以处理多个分支的if选择结构

if(条件){
            //代码块1
}else if(条件){
            //代码块2
}else{
            //代码块3
}

嵌套if：可以处理某分支中嵌套if结构的if选择结构

if(条件1) {
    //满足条件一的情况下在判断条件二
      if(条件2) {
            //代码块1
      } else {
            //代码块2
      }
} else {
     //代码块3
}

switch选择结构

switch(表达式){
    case 常量一:
            //代码块1
        break;
    case 常量二:
            //代码块2
        break;
    default:
        //没有找到匹配的值执行的代码
        break;
}
表达式：int char byte 枚举  short String
每个case后不漏写break,记得跳出

switch和多重if区别

相同点：
            都是用来处理多分支条件的结构
不同点：  
            switch:只能处理等值条件判断
            多重if:判断某个连续区间   

异常处理

Scanner对象的hasNextInt()方法，可以判断用户从键盘输入的字符是否是合法的数字
例如：
    if（scanner.hasNextInt()）{
            int num = scanner.inputInt();
    }else{
            System.out.println("输入不是数字哦");
    }

比较:

    比较int double类型使用==
    比较字符串使用.equals();

选择总结；

if选择结构

    基本if选择结构： 处理单一或组合条件的情况
    if-else选择结构：处理简单的条件分支情况
    多重if选择结构：处理复杂的条件分支情况
    嵌套if选择结构：用于较为复杂的流程控制

switch选择结构

    多重分支并且条件判断是等值判断的情况

第四章

循环

while循环

//符合条件，循环继续执行；否则，循环退出
while ( 循环条件 ) { 
       循环操作
}
示例：循环输出100遍我要好好学习天天向上。
     int i =1;
     while (i<=100){
        System.out.println("第"+i+"遍：我要好好学习天天向上");
        i++;
     }
特点：先判断，再执行 

程序调试

1：设置断点
2：单步执行
3：观察变量

do while循环

语法：
//先执行一遍循环操作
do {

        循环操作

} while ( 循环条件 );//分号必须有
//符合条件，循环继续执行；否则，循环退出

特点：先执行，再判断

do while 和while区别

1：语法不同 
略

2：执行顺序不同
    while 是先判断再执行循环操作，do while则刚好相反

3:当初始条件不满足循环条件的时候
    while 循环一次都不会执行
   do while 循环不管任何情况都至少执行一次

for循环

语法：
    for(参数初始化;循环条件;更新循环变量){
        循环操作
    }
示例：循环输出100以内偶数之和
    //定义总和
        int sum = 0;
        for (int i = 0; i <=100; i++) {
            if(i%2==0){
                sum=sum+i;
            }
        }
    System.out.println("100以内所有偶数和"+sum);
for循环执行顺序：参数初始化-->循环条件-->循环操作-->更新循环变量
for循环书写顺序：参数初始化-->循环条件-->更新循环变量-->循环操作 

注意： 代码规范：格式对齐、代码的缩进    

break使用：

break：改变程序控制流
当用于do-while、while、for等循环结构中时，可跳出循环而执行循环后面的语句
示例：
        //使用循环进行累加，从1到10
        //判断累加值是否大于20
        //如果大于20，则跳出循环，并打印当前值
        //定义累加值初始变量
        int number =0;
        for (int i = 1; i <=10; i++) {
            //累加值
            number=number+i;
            //如果大于20,打印当前值,跳出循环
            if(number>20){
                //打印当前值
                System.out.println(i);
                //!!!:跳出循环而执行循环后面的语句
                break;
            }
        }
     System.out.println("程序结束);

continue使用：

continue ：只能用在循环结构中
作用：跳过循环体中剩余的语句而执行下一次循环
    通常与条件语句一起使用，加速循环
示例：求1~10之间的所有偶数和（使用continue）
实现思路：
        使用循环进行累加，循环的范围是从1至10
        判断当前数是否为偶数    
        如果为奇数跳过，执行下一个循环。如果为偶数，进行累加    
    int sum = 0; // 定义一个变量，进行累加
        for (int i = 1; i <= 10; i++) {
            //判断是否偶数,一个数%2==1的时候这个数就是奇数,==0的整个
            if (i % 2 == 1) {
                //！！！继续下一次循环
                continue;// 如果i为奇数,结束本次循环，不累加，进行下一次循环
            }
            sum = sum + i;
        }
    System.out.print("1--10之间的偶数和是:" + sum);

对比break和continue：

使用场合：
    break可用于switch结构和循环结构中
    continue一般只用于循环结构中
作用（循环结构中）：
    break语句用于终止循环，程序跳转到循环体外的下一条语句
    continue用于跳出本次循环，进入下一次循环 
扩展：oop面向对象用到：    
    return：结束当前方法的执行并退出，返回到调用该方法的语句处

循环结构总结

无论哪一种循环结构，都有4个必不可少的部分：
    重点！！！:初始部分、循环条件、循环体、迭代部分

三种循环的区别:
区别1：语法
    略
区别2：执行顺序 
    while 循环：先判断，再执行
    do-while循环：先执行，再判断
    for循环：先判断，再执行
区别3：适用情况
    循环次数确定的情况，通常选用for循环
    循环次数不确定，通常选用while或do-while循环

重点！！！:三种循环的特点:

while循环的特点是先判断后执行

do-while循环的特点:
    先执行，再判断
    循环操作至少执行一次

for循环结构与跳转语句:
    for循环结构
        确定循环次数
        特点：先判断，再执行

    跳出循环的语句
        break：循环结构中遇到break语句，将会跳出其所在的循环，执行该循环结构后的第一条语句
        continue：结束本次循环，进入下一次循环的条件判断

第五章

数组

为什么需要数组

题目：计算全班（30人）的平均分

int stu1 = 95;
int stu2 = 89;
int stu3 = 79;
int stu4 = 64;
int stu5 = 76;
int stu6 = 88;
……
avg = (stu1+stu2+stu3+stu4+stu5…+stu30)/30;

弊端：
1:声明30个变量太繁琐
2:且不利于数据处理(计算)

什么是数组

数组是一个变量，用来存储一组相同数据类型的数据

    声明一个变量就是在内存空间划出一块合适的空间

    声明一个数组就是在内存空间划出一串连续的空间

数组基本要素：

标识符：数组的名称，用于区分不同的数组
数组元素：向数组中存放的数据
元素下标：对数组元素进行编号，从0开始，数组中的每个元素都可以通过下标来访问
元素类型：数组元素的数据类型  

注意:数组长度固定不变，避免数组越界

如何使用数组：

//例如:定义一个存储分数的数组
//使用数组四步走:
        //第一步：声明数组
        int[] score;

        //第二步：分配空间
        score=new int[5];

        //第三步：赋值
        score[0]=80;

        //第四步：处理数组
        score[0]=score[0]*10;  

声明数组：

声明数组: 告诉计算机数据类型是什么
示例:int[ ] JavaScore;   //Java成绩

语法:    数据类型    数组名[ ] ; 
     数据类型[ ]  数组名 ; 

注意:声明数组时不能规定数组长度

分配空间:

分配空间: 告诉计算机分配几个连续的空间
    JavaScore = new int[30]; 

语法:声明数组并分配空间
    数据类型[ ]  数组名   =   new   数据类型[大小]  ;                 
示例：
    int[] JavaScore = new int[30];

数组赋值：

赋值：向分配的空间里放入数据
    JavaScore[0] = 89;
    JavaScore[1] = 79;
    JavaScore[2] = 76;
    ……
    太麻烦！能不能一起赋值？

方法1: 边声明边赋值
    int[ ] JavaScore = {89, 79, 76};
    int[ ] JavaScore = new int[ ]{89, 79, 76};
注意：不能指定数组长度          

方法2：动态地从键盘录入信息并赋值    
    int[] JavaScore=new int[5];
    Scanner input = new Scanner(System.in);
    for(int i = 0; i < JavaScore.length; i ++){
         score[i] = input.nextInt();
    }

处理数据:

对数据进行处理：计算5位学生的javaScore平均分
方式一：
    int [ ] JavaScore = {60, 80, 90, 70, 85};
    double avg;
    avg = (JavaScore[0] + JavaScore[1] + JavaScore[2] + JavaScore[3] + JavaScore[4])/5;  


方式二:
    int [ ] JavaScore = {60, 80, 90, 70, 85};
    int sum = 0;
    double avg;
    for(int i = 0; i < JavaScore.length; i++){
         sum = sum + JavaScore[i];
    }
    avg = sum / JavaScore.length; 

注释：
1:访问数组成员：使用“标识符[下标]”
2:数组的length属性
3:JavaScore[i]:访问成员

提问使用数组求10个学生的平均分:

    Scanner scanner = new Scanner(System.in);
        //定义存储java成绩数组
        int[] JavaScore=new int[10];
        //定义java成绩数组的总和    
        int sum=0;
        for (int i = 0; i < JavaScore.length; i++) {
            System.out.println("请输入第"+(i+1)+"个学生Java成绩:");
            JavaScore[i]=scanner.nextInt();
            sum =sum+JavaScore[i];
            //简写：sum+= JavaScore[i];
        }
        System.out.println("30个学生的java平均分是："+(sum/JavaScore.length));

数组升序排序:

题目：循环录入5位学员成绩，进行升序排列后输出结果

提示：

    使用java.util.Arrays类
    注意导包：java.util下的
    Arrays类的sort()方法：对数组进行升序排列

public class ScoreSort {
    public static void main(String[] args) {
        int[] scores = new int[5];    //成绩数组
        Scanner input = new Scanner(System.in);
        System.out.println("请输入5位学员的成绩：");
        //循环录入学生成绩并存储在数组中
        for(int i = 0; i < scores.length; i++){
            scores[i] = input.nextInt();
        }
        //数组中的元素被重新排列
        Arrays.sort(scores);    
        System.out.print("学员成绩按升序排列：");
        //循环输出数组中的信息
        for(int i = 0; i < scores.length; i++){
            System.out.print(scores[i] + " ");
        }
    }
}

使用Arrays类的各种方法:

public class Arrays_Study {
    public static void main(String[] args) {
        //返回值：boolean 方法名称:equals(array1,array2)
        //作用：比较数组array1和array2是否相等
        System.out.println("---------equals(array1,array2)方法:----------");
        int[] arr1={10,50,90,80,60};
        int[] arr2={10,50,90,80,60};
        int[] arr3={20,40,90};
        //判断arr1与arr2的长度及元素是否相等
        System.out.println(Arrays.equals(arr1,arr2));
        //判断arr1与arr3的长度及元素是否相等
        System.out.println(Arrays.equals(arr1,arr3));

        //方法名称： sort(array)
        //作用：对数组array的元素进行升序排列
        System.out.println("\n---------sort(array)方法:----------");
        int[] JavaScores ={90,50,100,60,30,70};
        //对数组进行升序排列
        Arrays.sort(JavaScores);
        System.out.println("Java成绩升序排列后：");
        for (int i = 0; i <JavaScores.length ; i++) {
            System.out.print(JavaScores[i]+"\t");
        }

        System.out.println();
        //返回值：String 方法名称：toString(array)
        //作用:将数组array转换成一个字符串
        System.out.println("\n---------toString(array)方法:----------");
        int[] SqlScores = {70,80,50,40,60,20};
        //对数组进行升序排列
        Arrays.sort(SqlScores);
        //将SqlScores数组转换为字符串并输出
        System.out.println(Arrays.toString(SqlScores));

        //方法名称：fill(array,val)
        //作用：把数组array所有元素都赋值为value
        System.out.println("\n---------fill(array,val)方法:----------");
        int[] HtmlScores = {70,50,90,40,30,100};
        Arrays.fill(HtmlScores,60);
        //将HtmlScores数组转换为字符串并输出
        System.out.println(Arrays.toString(HtmlScores));

        //方法名称：copyOf(array,length)
        //作用：把数组array复制成一个长度为length的新数组，返回类型与复制的数组一致
        System.out.println("\n---------copyOf(array,length)方法:----------");
        int[] arr11={10,90,80,70,60};
        int[] arr22=Arrays.copyOf(arr11,6);
        System.out.println(Arrays.toString(arr22));
        int[] arr33=Arrays.copyOf(arr11,3);
        System.out.println(Arrays.toString(arr33));
        //将arr11复制成长度为5的新数组arr44
        int[] arr44=Arrays.copyOf(arr11,5);
        System.out.println(Arrays.toString(arr44));

        //返回值：int 方法名称：binarySearch(array, val)
        //作用：查询值val在数组array中的下标
        //（要求数组中元素已经按升序排列，如果没有找到，则返回一个负整数）
        System.out.println("\n---------binarySearch(array, val)方法:----------");
        int[] MathScores ={60,70,40,20,80,100};
        Arrays.sort(MathScores);
        int index = Arrays.binarySearch(MathScores,99);
        System.out.println(index);
        int indexTwo = Arrays.binarySearch(MathScores,20);
        System.out.println(indexTwo);
    }
}

求数组最大值：

题目:从键盘输入五位学生的成绩，求考试成绩最高分

示例：

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        //定义存储5个学生的成绩数组
        int[] scores = new int[5];
        //记录最大值
        int max = 0;    
        System.out.println("请输入5位学员的成绩：")
        for(int i = 0; i < scores.length; i++){
            scores[i] = input.nextInt();
        }
        //假设第一个元素为最大的成绩
        max = scores[0];
        //从第一个成绩开始比较
        for(int i = 1; i < scores.length; i++){
            //循环判断
            if(scores[i] > max){
                max = scores[i];
            }
        }
        System.out.println("考试成绩最高分为：" + max);
    }

数组降序排序:

实现思路：
  1:先使用arrays类的sort方法进行升序排列
  2:再使用for循环降序排列
  int[] numbers = {9,41,52,1,8,90,60};
  Arrays.sort(numbers);

  //从最后一个下标的输入开始  小于第一个下标   递减
  for (int i = numbers.length-1; i >=0 ; i--) {
            System.out.println(numbers[i]);
  }       

二维数组：

语法：
    <数据类型>  [ ][ ]  数组名;  或者  <数据类型>  数组名 [ ][ ];
示例：
    int [ ][ ] scores;   //定义二维数组
    scores=new int[5][50];  //分配内存空间
    或者
    int [ ][ ] scores = new int[5][50];

注意：定义二维数组时，要定义最大维数
    二维数组本质上仍是一个一维数组，只是它的每个元素又是一个一维数组

二维数组例图

int[][] s =new int[3] [5];

二维数组定义:

定义并赋值
写法一
    int[][] scores=new int[][]{ { 90, 85, 92, 78, 54 }, { 76, 63,80 }, { 87 }};

写法二
    int scores[][] = {{ 90, 85, 92, 78, 54 }, { 76, 63,80 }, { 87 } };

写法三
    int[][] scores ={{4},{5,78,18,13,78},{45,788}};