@scric 2016-09-26T09:07:45.000000Z 字数 11255 阅读 1791

JAVA学习

JAVA 学习 待更新

JAVA学习
# 如何命名 Java 变量
- ## 使用规则
#　Java 中的数据类型
- Java 中的赋值运算符
- ## 获得用户输入
#什么是数组

# 如何命名 Java 变量

1、变量名由多单词组成时，第一个单词的首字母小写，其后单词的首字母大写，俗称骆驼式命名法（也称驼峰命名法），如 myAge

2、变量命名时，尽量简短且能清楚的表达变量的作用，做到见名知意。如：定义变量名 stuName 保存 “学生姓名” 信息

3、PS： Java 变量名的长度没有限制，但 Java 语言是区分大小写的，所以 price 和 Price

## 使用规则

1、Java 中的变量需要先声明后使用
2、变量使用时，可以声明变量的同时进行初始化，也可以先声明后赋值
3、变量中每次只能赋一个值，但可以修改多次
4、main 方法中定义的变量必须先赋值，然后才能输出
5、虽然语法中没有提示错误，但在实际开发中，变量名不建议使用中文，容易产生安全隐患，譬如后期跨平台操作时出现乱码等等

#　Java 中的数据类型

Java 语言是一种强类型语言。通俗点说就是，在 Java 中存储的数据都是有类型的，而且必须在编译时就确定其类型。

自动类型转换
1. 目标类型能与源类型兼容，如 double 型兼容 int 型，但是 char 型不能兼容 int 型
2. 目标类型大于源类型，如 double 类型长度为 8 字节， int 类型为 4 字节，因此 double 类型的变量里直接可以存放 int 类型的数据，但反过来就不可以了

Java 中的强制类型转换

例如，当程序中需要将 double型变量的值赋给一个 int型变量，该如何实现呢？

显然，这种转换是不会自动进行的！因为 int 型的存储范围比 double 型的小。此时就需要通过强制类型转换来实现了。

public class HelloWorld{public static void main(String[] args) {
            double heightAvg1=176.2;
            int heightAvg2=***(int)***heightAvg1;
            System.out.println(heightAvg1);
            System.out.println(heightAvg2);
        }
    }

Java 常量的应用

语法：final 常量名 = 值;

public class HelloWorld{public static void main(String[] args) 
{
    final String Sex="男";
    final String Sex1="女";
    System.out.println(Sex);
  System.out.println(Sex1);
}}

如何在 Java 中使用注释

Java 中的算术运算符

其中，++ 和 -- 既可以出现在操作数的左边，也可以出现在右边，但结果不同

运行结果：

    a=6
    b=6

a=6
b=5

一定要注意！自增和自减运算符只能用于操作变量，不能直接用于操作数值或常量！例如 5++ 、 8-- 等写法都是错误滴！
PS：% 用来求余数，也称为” 取模运算符 “

请在编辑器的指定行中输入代码实现功能

第 7 行：求取四个年龄的总和
第 8 行：求取四个年龄的平均值
第 9 行：求取 age1 和 age2 的差值
第 10 行：求取 age1 自减后的年龄

package com.hello;
public class hello{public static void main(String[] args) {
        int age1=24;
        int age2=18;
        int age3=36;
        int age4=27;
    int sum=age1+age2+age3+age4;
    double avg=sum/4;
    int minus=age1-age2;
    int newAge=age1--;
        System.out.println("年龄总和："+sum);
        System.out.println("平均年龄："+avg);
        System.out.println("年龄差值："+minus);
        System.out.println("自减后的年龄："+newAge);
        System.out.println("自减后的age1："+age1);
    }
}

Java 中的赋值运算符

请在编辑器中，空白处编写代码，应用赋值运算符实现如下结果：

package com.hello;
public class hello{public static void main(String[] args) {
    int one = 10 ;
    int two = 20 ;
    int three = 0 ;
        System.out.println("three=one+two==>"+(three=one+two));
        System.out.println("three+=one==>"+(three+=one));
        System.out.println("three-one==>"+(three-=one));
        System.out.println("three*=one==>"+(three*=one));
        System.out.println("three/=one==>"+(three/=one));
        System.out.println("three%=one==>"+(three%=one));
    }
}

还有一种方法是

Java 中的比较运算符
比较运算符用于判断两个数据的大小，例如：大于、等于、不等于。比较的结果是一个布尔值（ true 或 false ）。

Java 中常用的比较运算符如下表所示：

package com.hello;
public class hello{public static void main(String[] args) {
    int a=16;
    double b=9.5;
    String str1="hello";
    String str2="imooc";
    System.out.println("a 等于 b：" + (a  == b));
    System.out.println("a 大于 b：" + (a  > b));
    System.out.println("a 小于等于 b：" + (a <=  b));
    System.out.println("str1 等于 str2：" + (str1==str2));
    }
}

注意：

1、 > 、 <、>= 、 <= 只支持左右两边操作数是数值类型

2、 == 、 != 两边的操作数既可以是数值类型，也可以是引用类型

Java 中的逻辑运算符
此处输入图片的描述
我们可以从 “投票选举” 的角度理解逻辑运算符：

1、与：要求所有人都投票同意，才能通过某议题

2、或：只要求一个人投票同意就可以通过某议题

3、非：某人原本投票同意，通过非运算符，可以使其投票无效

4、异或：有且只能有一个人投票同意，才可以通过某议题

当使用逻辑运算符时，我们会遇到一种很有趣的 “短路” 现象。

譬如：(one> two ) && (one < three) 中，如果能确定左边 one > two 运行结果为 false , 则系统就认为已经没有必要执行右侧的 one < three 啦。

同理，在 (one> two ) || (one < three) 中，如果能确定左边表达式的运行结果为 true , 则系统也同样会认为已经没有必要再进行右侧的 one < three 的执行！

Java 中的条件运算符
条件运算符（ ? : ）也称为 “三元运算符”。

语法形式：布尔表达式？表达式 1 ：表达式 2

运算过程：如果布尔表达式的值为 true ，则返回表达式 1 的值，否则返回表达式 2 的值

Java 中运算符的优先级

实际开发中，一般会使用小括号辅助进行优先级管理。
换句话说：所有运算符中，( ) 的优先级最高
例如：

Java 条件语句

if
if else

实现功能 “如果年龄大于等于 18 岁，则提示成年了，否则提示未成年”

package com.hello;
public class hello{public static void main(String[] args) 
    {int age=25 ;
    if(age>=18)
    System.out.println("成年");
    else
        System.out.println("未成年");
    }}

多重 if 语句，在条件 1 不满足的情况下，才会进行条件 2 的判断；当前面的条件均不成立时，才会执行 else 块内的代码。

假设年龄大于 60 岁，则提示 “老年”；如果年龄介于 40 岁至 60 岁之间，则提示 “中年”；如果年龄介于 18 岁至 40 岁之间，则提示 “少年”； 18 岁以下则提示 “童年”

运行结果为：少年

package com.hello;
public class hello{public static void main(String[] args) 
    {int age=25 ;
    if(age>60)
    System.out.println("老年");
    else if(age>=40)
        System.out.println("中年");
    else if(age>=18)
        System.out.println("少年");
    else
        System.out.println("童年");
    }
    }

或者

package com.hello;
public class hello{public static void main(String[] args) 
    {int age=25 ;
    System.out.println(age>60?"老年":age>40?"中年":age>18?"少年":"童年");
    }
    }

嵌套 if 语句

只有当外层 if 的条件成立时，才会判断内层 if 的条件。

例子

：预赛成绩大于 80 分的可进入决赛，然后根据性别再划分为男子组决赛和女子组决赛。

运行结果为：进入女子组决赛

package com.hello;
public class hello{public static void main(String[] args) 
    {       int score = 94;
    String sex = "女";
    if(score>=80){
        if(sex.equals("女"))
        System.out.println("进入女子组决赛");
        else
            System.out.println("进入男子组决赛");
            }
    else
        System.out.println("不进入决赛");
    }
    }

Java 条件语句之 switch
当需要对选项进行等值判断时，使用 switch 语句更加简洁明了。例如：根据考试的名次，给予前 4 名不同的奖品。第一名，奖励笔记本一台；第二名，奖励 IPAD 2 一个；第三名，奖励移动电源一个；最后一名奖励 U 盘一个。

执行过程：当 switch 后表达式的值和 case 语句后的值相同时，从该位置开始向下执行，直到遇到 break 语句或者 switch 语句块结束；如果没有匹配的 case 语句则执行 default 块的代码

此处输入图片的描述

注意：

1、 switch 后面小括号中表达式的值必须是整型或字符型

2、 case 后面的值可以是常量数值，如 1、2；也可以是一个常量表达式，如 2+2 ；但不能是变量或带有变量的表达式，如 a * 2

3、 case 匹配后，执行匹配块里的程序代码，如果没有遇见 break 会继续执行下一个的 case 块的内容，直到遇到 break 语句或者 switch 语句块结束

请在代码编辑器中，使用 switch 语句补全代码，设置属于你的菜谱：如果今天是星期一、三、五，则早餐吃包子，如果是星期二、四、六，则早餐吃油条，如果是星期日，则吃 “主席套餐”

运行结果为：吃主席套餐

package com.hello;
public class hello{public static void main(String[] args) 
    {int today= 7;
    switch(today){
    case 1:
    case 3:
    case 5:
        System.out.println("吃包子");break;
    case 2:
    case 4:
    case 6:
        System.out.println("吃油条");break;
    case 7:
        System.out.println("主席套餐");
    }
    }
    }

Java 循环语句之 while

执行过程：

<1>、判断 while 后面的条件是否成立 (true / false)

<2>、当条件成立时，执行循环内的操作代码，然后重复执行 <1>、<2>，直到循环条件不成立为止

特点：先判断，后执行
如：

实现功能：顺序输出 1 ～ 5 这 5 个数字。

实现思路：使用一个变量 i 代表 1 - 5 之间的数字，值从 1 开始，每次循环时输出 i 的值，并且对 i 的值加 1 ，只要 i 小于等于数字 5 就执行该循环

package com.hello;
public class hello{public static void main(String[] args) 
    { int i = 1;   //初始化i并赋值
      while (i<=5)   //当i小于等于5时运行花括号内语句
    {
        System.out.println(i);
        i++;   //i使用后自增1
    }
    }
    }

Java 循环语句之 do...while

执行过程：

<1>、先执行一遍循环操作，然后判断循环条件是否成立

<2>、如果条件成立，继续执行 <1> 、<2>，直到循环条件不成立为止

特点：先执行，后判断

由此可见，do...while 语句保证循环至少被执行一次！

实现功能：计算 50 以内（包括 50 ）的偶数之和

实现思路：首先定义一个变量 sum ，用来保存所有偶数的和，然后定义一个变量 num 代表 1--50 之间的偶数，值从 2 开始，每次循环执行时将 num 的值累加保存在变量 sum 中，并且将 num 值加 2 (偶数嘛，你懂得哈~~)，只要 num 的值在 1--50 之内就重复执行该循环

package com.hello;
public class hello{public static void main(String[] args) 
    { 
    int sum = 0; 
    int num = 2; 
    do {
        sum+=num;
        num = num + 2; // 每执行一次将数值加 2，以进行下次循环条件判断
    } while (num<=50); // 满足数值在 1-50 之间时重复执行循环
    System.out.println("50 以内的偶数之和为：" + sum);
    }
}

试交换第八第九行语句，如何更改使得结果为650

for循环

实现功能：计算 1 到 100 之间不能被 3 整除的数之和

package com.hello;
public class hello
    {
    public static void main(String[] args) 
    { 
    int sum = 0; 
    for (int i = 1;i<=100;i++) 
    {
     if (i % 3 != 0)
      sum = sum + i; 
     }
    System.out.println(sum);
     }
     }

注意作用域。

Java 循环跳转语句之 break

在 Java 中，我们可以使用 break 语句退出指定的循环，直接执行循环后面的代码。

例如，使用循环输出 1--10 的数值，其中，如果数值大于 2 ，并且为 3 的倍数则停止输出。

实现代码：

实现功能：循环将 1 到 10 之间的整数相加，如果累加值大于 20，则跳出循环，并输出当前的累加值。

实现思路：定义一个变量 sum 保存累加值，定义一个变量 i 保存 1 至 10 之间的整数，在循环中进行累加求和，同时判断累加值是否大于 20 ，当大于 20 时输出当前的累加值并退出循环。

package com.hello;
public class hello{public static void main(String[] args)
    {
    int sum = 0;
    for (int i = 1; i <= 10; i++)
    {
    sum = sum + i;      
        if (sum>=20) 
        break;
    }
    System.out.print(" 当前的累加值为:"+ sum);
    }
}

同样要注意作用域。搞清楚break会退出哪个循环。

Java 循环跳转语句之 continue

continue 的作用是跳过循环体中剩余的语句执行下一次循环。

例如，打印 1--10 之间所有的偶数，使用 continue 语句实现代码为：

实现功能：求 1 到 10 之间的所有偶数的和。

实现思路：定义一个变量 sum 保存累加值，定义一个变量 i 保存 1 到 10 之间的整数，循环遍历并进行判断，如果 i 不能被 2 整除，则结束本次循环，继续执行下一次循环，否则进行累加求和。

package com.hello;
public class hello
{public static void main(String[] args)
    {
     int sum = 0; 
     for (int i = 1; i <= 10; i++)   
     {
        if (i%2!=0) {
            continue;}
        sum = sum + i;
     }
       System.out.print("1 到 10 之间的所有偶数的和为：" + sum);
    }
}

这里需要注意break和continue的区别。

break是退出整个循环，执行循环后的语句；而continue则是退出当前循环，继续进行下一次循环，并未退出整个循环。

Java 循环语句之多重循环

循环体中包含循环语句的结构称为多重循环。三种循环语句可以自身嵌套，也可以相互嵌套，最常见的就是二重循环。在二重循环中，外层循环每执行一次，内层循环要执行一圈

打印长方形

执行流程：当 i = 1 时，外层循环条件成立，进入内层循环，开始打印第一行内容。此时， j 从 1 开始，循环 8 次，内层循环结束后换行，实现第一行 8 个 * 的输出。接下来返回外层循环 i 变为 2 ，准备打印下一行，依此类推，直到完成长方形的打印。

实现功能：使用 * 打印直角三角形

实现思路：上面的图形中，第 1 行有一个 * 号，第 2 行有两个 * 号，第 3 行有三个 * 号，所以可以使用二重循环来实现。其中，外层循环控制行数，内层循环控制每行的 * 号数。同时，我们发现一个规律，当打印每行信息时，内层循环变量的最大值和外层循环变量的值相等。

package com.hello;
public class hello
{public static void main(String[] args)
    {
    for (int i = 1;i<=3;i++) {
    for(int j=1;j<=i;j++) 
    {
    System.out.print("*");
    }
    System.out.println();
                             }
    }
}

为什么有的是print。有的是println呢？
print和println的区别在哪里？
如果想都改成print或者是println该怎么做呢？

判断一个数（小于 10 位）的位数。
输入 999，则输出 “它是个 3 位的数！”

package com.hello;
public class hello
{public static void main(String[] args)
    {
    int count;
    int num=9999;
    for(count=1;(num/=10)>0;count++);
    System.out.println("它是个"+count+"位的数！");
    }
}

试试还有没有其他的方式；

为指定成绩加分，直到分数大于等于 60 为止，输出加分前和加分后的成绩，并统计加分的次数

package com.hello;
public class hello
{public static void main(String[] args)
    {
    int score = 53;     
    int count = 0;
    System.out.println("加分前成绩:"+score);
    for(score=53;score<60;count++)
        score++;
    System.out.println("加分后成绩:"+score);
    System.out.println("共加了:"+count+"次");
    }
}

## 获得用户输入

package com.hello;
import java.util.Scanner;
public class hello
{public static void main(String[] args)
    {
    Scanner input=new Scanner(System.in);
    System.out.println("请输入考试成绩信息:");
    int score = input.nextInt();     
    int count = 0;
    System.out.println("加分前成绩:"+score);
    for(;score<60;count++)
        score++;
    System.out.println("加分后成绩:"+score);
    System.out.println("共加了:"+count+"次");
}
}

package com.hello;
import java.util.Scanner;   //调用输入函数
public class hello
{public static void main(String[] args)
    {
    Scanner input=new Scanner(System.in);
    int classNum=3;
    int stuNum=4;
    double sum=0 ;
    double avge=0;
    for(int i=1;i<=classNum;i++)
    {   sum=0;
    System.out.println("***请输入第"+i+"个班级的成绩***");
    for(int j=1;j<=stuNum;j++)
    {
        System.out.print("请输入第"+j+"个学生的成绩:");
        int score=input.nextInt();
        sum=sum+score;
    }
    avge=sum/stuNum;
    System.out.println("第"+i+"个班级的平均分:"+avge);
    System.out.println("第"+i+"个班级的总分:"+sum);    
    }
}
}

#什么是数组

数组可以理解为是一个巨大的 “盒子”，里面可以按顺序存放多个类型相同的数据，比如可以定义 int 型的数组 scores 存储 4 名学生的成绩

##　如何使用 Java 中的数组

1、声明数组

语法：数据类型 [ ] 数组名；

或者数据类型数组名 [ ]；

其中，数组名可以是任意合法的变量名，如：

2、分配空间

简单地说，就是指定数组中最多可存储多少个元素

语法：数组名 = new 数据类型 [数组长度];

其中，数组长度就是数组中能存放元素的个数，如：

话说，我们也可以将上面的两个步骤合并，在声明数组的同时为它分配空间，如：

4、处理数组中数据

我们可以对赋值后的数组进行操作和处理，如获取并输出数组中元素的值

package com.hello;
public class hello
{public static void main(String[] args)
    {
    String[] subjects = new String[5];
    // 分别为数组中的元素赋值
    subjects[0] = "Oracle";
    subjects[1] = "PHP";
    subjects[2] = "Linux";
    subjects[3] = "Java";
    subjects[4] = "HTML";   
    System.out.println("数组中第 4 个科目为：" +subjects[3]);
    }
}

或者

package com.hello;
public class hello{public static void main(String[] args)
    {
    String[] subjects = {"Oracle","PHP","Linux","Java","HTML"};
    System.out.println("数组中第 4 个科目为：" +subjects[3]);
    }
}

## 使用循环操作 Java 中的数组

其中，数组名. length 用于获取数组的长度

需要注意的 “小毛病”：

1、数组下标从 0 开始。因此 scores3 ，表示数组中的第 4 个元素，而并非第 3 个元素

2、数组下标的范围是 0 至数组长度 - 1 ，如果越界访问，就会报错。
如

    String[] hobbys = {"sports","game","movie"};
    System.out.println("循环输出数组中元素的值：");
    for(int i=1;i<=hobbys.length;i++)
        System.out.println(hobbys[i-1]);    
}

任务要求：

1、定义一个整型数组，并赋初值 61, 23, 4, 74, 13, 148, 20

2、定义变量分别保存最大值、最小值、累加值和平均值，并假设数组中的第一个元素既为最大值又为最小值

3、使用 for 循环遍历数组中的元素，分别与假定的最大值和最小值比较。如果比假定的最大值要大，则替换当前的最大值；如果比假定的最小值要小，则替换当前的最小值

4、循环执行过程中对数组中的元素进行累加求和

5、循环结束根据累加值计算平均值，并打印输出相关内容

package com.hello;
public class hello
{public static void main(String[] args)
    {   
    int[] nums = new int[] {61, 23, 4, 74, 13, 148, 20};   
    int max = nums[0]; // 假定最大值为数组中的第一个元素
    int min = nums[0]; // 假定最小值为数组中的第一个元素
    double sum = 0;// 累加值
    double avg = 0;// 平均值
    for (int i = 0; i < nums.length; i++) 
    { 
        if (nums[i]>max)
        max=nums[i];        // 如果当前值大于 max，则替换 max 的值
        else if (nums[i]<min)
        min=nums[i];        // 如果当前值小于 min，则替换 min 的值
        sum+=nums[i];       // 累计求和
    }
    avg=sum/7;              //求平均值
    System.out.println("数组中的最大值：" + max);
    System.out.println("数组中的最小值：" + min);
    System.out.println("数组中的平均值：" + avg);
    }
}

## 使用 Arrays 类操作 Java 中的数组

Arrays 类是 Java 中提供的一个工具类，在 java.util 包中。该类中包含了一些方法用来直接操作数组，比如可直接实现数组的排序、搜索等（关于类和方法的相关内容在后面的章节中会详细讲解滴~~）。

Arrays 中常用的方法：

1、排序

语法： Arrays.sort(数组名);

可以使用 sort() 方法实现对数组的排序，只要将数组名放在 sort() 方法的括号中，就可以完成对该数组的排序（按升序排列），如：

2、将数组转换为字符串

语法： Arrays.toString(数组名);

可以使用 toString( ) 方法将一个数组转换成字符串，该方法按顺序把多个数组元素连接在一起，多个元素之间使用逗号和空格隔开，如：

## 使用 foreach 操作数组

foreach 并不是 Java 中的关键字，是 for 语句的特殊简化版本，在遍历数组、集合时， foreach 更简单便捷。从英文字面意思理解 foreach 也就是 “for 每一个” 的意思，那么到底怎么使用 foreach 语句呢？

语法：

留个思考问题给大家：如果想在 foreach 语句中获取数组元素的下标，该如何做呢？？

在编辑器中定义了一个整型数组 scores ，保存学生成绩信息，通过 Arrays 类的 sort 方法对成绩数组进行排序，然后使用 foreach 遍历输出数组中的元素。

package com.hello;
import java.util.Arrays;
public class hello
{public static void main(String[] args)
    {   
    int i=0;
    int[] scores = { 89, 72, 64, 58, 93};
    Arrays.sort (scores);
    for ( int score:scores)
    {
        System.out.println(score);
        System.out.println("其下标为:"+i);
        i++;
    }
}
}

## Java 中的二维数组

所谓二维数组，可以简单的理解为是一种 “特殊” 的一维数组，它的每个数组空间中保存的是一个一维数组。

那么如何使用二维数组呢，步骤如下：

2、赋值

二维数组的赋值，和一维数组类似，可以通过下标来逐个赋值，注意索引从 0 开始

3、处理数组

二维数组的访问和输出同一维数组一样，只是多了一个下标而已。在循环输出时，需要里面再内嵌一个循环，即使用二重循环来输出二维数组中的每一个元素。如：
![][38]