JavaDay06

• 用户登录，提示用户输入用户名和密码,如果用户名和密码不是”admin”和”123”的话，就提示用户继续输入,最多输入五次

/*
    用户登录，提示用户输入用户名和密码
    如果用户名和密码不是"admin"和"123"的话，就提示用户继续输入
    最多输入五次
*/
import java.util.Scanner;

class Demo01{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String name ="";                            //定义变量保存用户名
        String pwd ="";                             //定义变量保存密码
        int count = 0;                              //统计用户输入的次数

            for ( int i=1 ; i<=5 ; i++ ){
            System.out.println("请输入用户名");
            name = sc.next();

            System.out.println("请输入密码");
            pwd = sc.next();

            //判断是否合法用户
            if ( "admin".equals(name) && "123".equals(pwd) ){
                System.out.println("登录成功");
                break;
            }else{
                System.out.println("用户名或密码不正确，还有" + (5-i) + "次机会");

            }
        }

    }
}

/*
    用户登录，提示用户输入用户名和密码
    如果用户名和密码不是"admin"和"123"的话，就提示用户继续输入
    最多输入五次
*/
import java.util.Scanner;

class Demo02{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String name ="";                            //定义变量保存用户名
        String pwd ="";                             //定义变量保存密码
        int count = 0;                              //统计用户输入的次数

                while ( !("admin".equals(name) && "123".equals(pwd)) ){
            //1)提示用户输入用户名和密码
            System.out.println("请输入用户名");
            name = sc.next();
            System.out.println("请输入密码");
            pwd = sc.next();

            //2)判断是否合法用户,如果合法就提示登录成功并退出循环
            if ( "admin".equals(name) && "123".equals(pwd) ){
                System.out.println("登录成功");
                break;
            }

            //3)统计用户输入的次数
            count++;

            //4)判断非法的次数是否已达5次，如果到了5次就退出循环
            if ( count>=5 ){
                System.out.println("已达到最大输错次数，请稍候重试");
                break;
            }else{

                //5)如果没到5次就提示剩余的次数
                System.out.println("用户名或密码不正确，还有" + (5-count) + "次机会");
            }
        }
    }
}

• 编写一个程序，从键盘上输入一个十进制正整数，输出它的二进制数

/*
    编写一个程序，从键盘上输入一个十进制正整数，输出它的二进制数
        num == 46;
        shang = num;
        r = num % 2;            //r==0
        shang = num / 2;        //shang==23
        r = shang % 2;          //r==1
        shang = num / 2;        //shang==11
*/
import java.util.Scanner;

class Demo03 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个十进制正整数");
        int num = sc.nextInt();

        int shang = num;
        int r = 0;
        String res = "";                //保存余数

        while ( shang != 0 ){
            r = shang % 2;
            res = r + res;
            shang = shang / 2;
        }

        System.out.println("十进制数"+num+"的二进制数为"+res);
    }
}

• 从键盘上输入一个整数，逆序输出

/*
    从键盘上输入一个整数，逆序输出
    输入：12       输出：21
    输入：123      输出：321
    输入：1234     输出：4321
    就是分别把个位、十位、百位、千位等各位的数字取出来
        个位：num % 10
        十位：num / 10 % 10
        百位：num / 10 / 10 % 10
        千位：num / 10 / 10 / 10 % 10
*/
import java.util.Scanner;

class Demo04 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数");
        int num = sc.nextInt();             //num == 123

        String res = "";                    //保存逆序之后的各个数值

        //如果是负数，先把负号打印出来，把负数变为正数
        if ( num<0 ){
//          System.out.print("-");
            res = res + "-";
            num = -1 * num;
        }

        while ( num != 0 ){
            int r = num % 10;                   //r == 3
//          System.out.print( r );
            res += r;
            num = num /10;                      //num == 12
        }

        //输出
        System.out.println("逆序后的结果"+res);

    }
}

/*
    从键盘上输入一个整数，逆序输出
*/
import java.util.Scanner;

class Demo05 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数");
        int num = sc.nextInt();             //num == -123

        int res = 0;                        //保存逆序之后的数

        while ( num != 0 ){
            int r = num % 10;                   //r == -1
            //构建新的整数
            res = res * 10 + r;                 //res == -321
            num = num / 10;                     //num == 0
        }

        //输出
        System.out.println("逆序后的结果"+res);

    }
}

• 求1-2+3-4+5-6+7-…+n的和

/*
    求1-2+3-4+5-6+7-...+n的和
*/
import java.util.Scanner;

class Demo06 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个正整数n");
        int n = sc.nextInt();

        int sum = 0;                //保存表达式的和

        for ( int i = 1 ; i <= n ; i++ ){
            if ( i % 2 == 1 ){
                sum += i;
            }else{
                sum -= i;
            }
        }

        System.out.println("sum=" + sum);
    }
}

• 求1/3 + 3/5 + 5/7 + 7/9 + … + 97/99的和

/*
    求1/3 + 3/5 + 5/7 + 7/9 + ... + 97/99的和
*/
class Demo07 {
    public static void main(String[] args) {
        double sum = 0;                     //保存累加和

        for ( int n = 1 ; n <= 97 ; n += 2 ){
            sum += n / ( n + 2.0 );
        }
        System.out.println( sum );
    }
}

• 求任意两个数范围内的奇数和

/*
    求任意两个数范围内的奇数和
*/
import java.util.Scanner;

class Demo08 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入两个整数");
        int m = sc.nextInt();
        int n = sc.nextInt();

        //遍历这两个整数m和n范围内所有的数，如果是奇数就累加

        //保证 m < n
        if ( m > n ){
            int t = m;
            m = n;
            n = t;
        }

        int sum = 0;                //保存累加和
        for ( int i = m ; i <= n ; i++ ){
            if ( i % 2 != 0 ){
                sum += i;
            }
        }
        System.out.println( m + "和" + n + "之间的奇数和为" + sum );
    }
}

• 编写程序，提示用户输入学生的个数，每个学生的名字及其分数,最后显示获得最高分的学生和第二高分的学生信息

/*
    编写程序，提示用户输入学生的个数，每个学生的名字及其分数
    最后显示获得最高分的学生和第二高分的学生信息
*/
import java.util.Scanner;

class Demo09 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入学生的个数");
        int num = sc.nextInt();

        String name1 = "";          //保存最高分学生的姓名
        int score1 = 0;             //保存最高分学生的成绩
        String name2 = "";          //保存第二高分学生的姓名
        int score2 = 0;             //保存第二高分学生的成绩

        //读取每个学生的名字和分数
        String name = "";           //保存学生的姓名
        int score = 0;              //保存学生的成绩
        for ( int i = 1 ; i <= num ; i++ ){
            System.out.println("请输入学生的姓名");
            name = sc.next();
            System.out.println("请输入学生的成绩");
            score = sc.nextInt();
            //如果刚输入同学的成绩比score1还高，刚输入的学生就是最高分学生信息
            if ( score > score1 ){
                //原来第一高分变为第二高分
                score2 = score1;
                name2 = name1;

                score1 = score;
                name1 = name;
            }else if ( score > score2 ){
                score2 = score;
                name2 = name;
            }
        }

        //输出结果时，根据学生的个数决定是否输出第二高学生的信息
        if ( num >= 2 ){
            System.out.println("姓名：" + name1 + "最高分：" + score1);
            System.out.println("姓名：" + name2 + "第二高分：" + score2);
        }else if ( num >= 1){
            System.out.println("姓名：" + name1 + "最高分：" + score1);
        }else{
            System.out.println("没有学生");
        }

    }
}

• 判断一个数是否为素数，素数又叫质数，是除了1和它本身之外不能被其它数整除的数

/*
    判断一个数是否为素数，素数又叫质数，是除了1和它本身之外不能被其它数整除的数
*/
import java.util.Scanner;

class Demo10 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个正整数");
        int num = sc.nextInt();

        //先假设num是素数
        boolean isPrime = true;

        //从2到num-1，如果有一个数能把num整除，说明num不是素数
        for ( int x=2 ; x<num ; x++ ){
            //如果有一个数x能把num整除，说明num不是素数
            if ( num%x == 0 ){
                isPrime = false;            //修改素数标志
                break;
            }
        }

        //根据素数标志isPrime来判断是否为素数
//      if ( isPrime == false ){
        if ( !isPrime ){
            System.out.println(num + "不是素数");
        }else{
            System.out.println(num + "是素数");
        }
    }
}

/*
    判断一个数是否为素数，素数又叫质数，是除了1和它本身之外不能被其他数整除的数
*/
import java.util.Scanner;

class Demo11 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个正整数");
        int num = sc.nextInt();

        //从2开始找能把num整除的数
        int chushu = 1;
        for ( int x=2 ; x<num ; x++ ){
            //如果有一个数x能把num整除，就保存到除数变量中
            if ( num%x == 0 ){
                chushu = x;
            }
        }

        //如果这个除数比1大，就说明有一个数能把num整除，不是素数
        if ( chushu > 1 ){
            System.out.println(num + "不是素数");
        }else{
            System.out.println(num + "是素数");
        }
    }
}

1 循环嵌套

在一个循环体中又包含另外一个循环，这就是循环的嵌套

• 打印m行n列的*号，m、n由用户决定

/*
    在屏幕上打印*号，打印的个数由用户决定
*/
import java.util.Scanner;

class Demo12 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入每行打印*号的个数");
        int num = sc.nextInt();
        System.out.println("请输入打印*号的行数");
        int rows = sc.nextInt();

        for ( int i=1 ; i<=rows ; i++ ){
            for ( int x=1 ; x<=num ; x++ ){
                System.out.print("*");
            }
            System.out.println();           //换行
        }

    }
}

• 打印*号图形

/*
    *
    **
    ***
    ****
    *****
*/
class Demo13 {
    public static void main(String[] args) {
        //有5行，每一行都是打印*号，再换行
        for ( int n=1 ; n<=5 ; n++ ){
            //打印*号，第n行需要打印n个*号
            for ( int x=1 ; x<=n ; x++ ){
                System.out.print("*");
            }
            //换行
            System.out.println();
        }
    }
}

/*
        *
       * *
      * * *
     * * * *
    * * * * *
*/
class Demo14 {
    public static void main(String[] args) {
        //有5行，每一行都是先打印空格，再打印*号，最后换行
        for ( int n=1 ; n<=5 ; n++ ){
            //打印空格，空格的数量==5-行数
            for ( int x=1 ; x<=5-n ; x++ ){
                System.out.print(" ");
            }
            //打印*号，第n行需要打印n个*号
            for ( int x=1 ; x<=n ; x++ ){
                System.out.print("* ");
            }
            //换行
            System.out.println();
        }
    }
}

/*
        *
       * *
      * * *
     * * * *
    * * * * *
     * * * *
      * * *
       * *
        *
*/
class Demo15 {
    public static void main(String[] args) {
        //上半部分
        //有5行，每一行都是先打印空格，再打印*号，最后换行
        for ( int n=1 ; n<=5 ; n++ ){
            //打印空格，空格的数量==5-行数
            for ( int x=1 ; x<=5-n ; x++ ){
                System.out.print(" ");
            }
            //打印*号，第n行需要打印n个*号
            for ( int x=1 ; x<=n ; x++ ){
                System.out.print("* ");
            }
            //换行
            System.out.println();
        }

        //下半部分
        for ( int n=4 ; n>=1 ; n-- ){
            //打印空格，空格的数量==5-行数
            for ( int x=1 ; x<=5-n ; x++ ){
                System.out.print(" ");
            }
            //打印*号，第n行需要打印n个*号
            for ( int x=1 ; x<=n ; x++ ){
                System.out.print("* ");
            }
            //换行
            System.out.println();
        }
    }
}

• 在内层循环中断外层循环

class Demo16 {
    public static void main(String[] args) {

        for ( int x=1 ; x<=10 ; x++ ){                          //外层循环
            for ( int y=1 ; y<=10 ; y++ ){                      //内层循环

                if ( y>=5 ){
                    break;                                      //中断的是包含它的循环，即内循环
                }
                System.out.println("x==" + x + "y==" + y);      
            }
        }
        System.out.println("---------------------------------------------");
        //在内层循环中中断外层循环
        outer:                                                  //定义一个标签
        for ( int x=1 ; x<=10 ; x++ ){                          //外层循环
            for ( int y=1 ; y<=10 ; y++ ){                      //内层循环

                if ( y>=5 ){
                    break outer;                                //中断的是标签标识的循环
                }
                System.out.println("x==" + x + "y==" + y);      
            }
        }
    }
}

• 打印1~100之间所有的素数

/*
    打印1~100之间所有的素数
*/
class Demo17 {
/*
    public static void main(String[] args) {
        //遍历1~100之间所有的数，如果这个数是素数就打印
        for ( int num=2 ; num<=100 ; num++ ){
            //如果num是素数就打印
            boolean isPrime = true;
            for ( int x=2 ; x<num ; x++ ){
                if ( num%x ==0 ){
                    isPrime = false;
                }
            }
            if ( isPrime ){
                System.out.println( num );
            }
        }
    }
*/
    public static void main(String[] args) {
        //遍历1~100之间所有的数，如果这个数是素数就打印
        for ( int num=2 ; num<=100 ; num++ ){
            //找num这个数，除了1和它本身之外的余数，如果还有就说明不是素数
            int chushu = 1;         //保存num的除数
            for ( int x=2 ; x<num ; x++ ){
                if ( num%x ==0 ){
                    chushu = x;
                }
            }
            if ( chushu==1 ){
                System.out.println( num );
            }
        }
    }
}

2 数组初步

2.1 数组的定义

1）为什么需要数组
保存一个数据可以定义一个变量，如果要保存80个数据？可以通过数组来保存。

2）数组的定义
变量就是内存中的一块存储空间。
数组就是内存中的一块连续的存储空间。

数组定义的格式：
数据类型 [] 数组名 = new 类型 [数组的长度]；

数组名里保存的是数组的起始地址。

class Demo18 {
    public static void main(String[] args) {

        //1.数据类型 []数组名 = new 类型 [数组的长度];
        //定义一个数组，可以存储80个同学的成绩
        int [] scoreArr = new int[80];
        /*
            scoreArr是数组名；
            scoreArr的数据类型是int []
            new int[80] 会在内存中分配一块连续的存储空间，这块存储空间可以存储80个int类型的数据
        */

        //在定义数组时，[]也可以写在数组名的后面
        int ageArr[] = new int[80];     //不建议这样写

        //在定义数组的同时，可以给数组的各个元素进行赋值
        int [] arr3 = {12,23,34,45,56};
        /*
            定义了一个数组arr3，这个数组的每个元素是12,23,34,45,56
            这个数组的长度就是初始化时指定的数组元素的个数
        */

        System.out.println("Hello World!");
    }
}

2.2 数组元素的访问

可以通过索引值（下标）来访问数组的各个元素
注意：
在Java中，索引值是从0开始的

class Demo18 {
    public static void main(String[] args) {

        //1.数据类型 []数组名 = new 类型 [数组的长度];
        //定义一个数组，可以存储80个同学的成绩
        int [] scoreArr = new int[80];
        /*
            scoreArr是数组名；
            scoreArr的数据类型是int []
            new int[80] 会在内存中分配一块连续的存储空间，这块存储空间可以存储80个int类型的数据
        */

        //2.通过索引值（下标）实现对数组元素的访问
        //给数组的元素进行赋值
        scoreArr[0] = 78;
        scoreArr[1] = 58;
        scoreArr[2] = 75;
        scoreArr[3] = 99;

        //读取数组元素
        System.out.println( scoreArr[0] );
        System.out.println( scoreArr[1] );
        System.out.println( scoreArr[2] );
        System.out.println( scoreArr[3] );
        System.out.println( "-------------------------------" );

        //3.通过循环遍历数组的各个元素
        //把数组的前10个元素打印到屏幕上
        for ( int i=0 ; i<=9 ; i++ ){
            System.out.println( scoreArr[i] );
        }

        /*4.定义了数组之后，系统会给数组的各个元素进行默认的初始化
            对于数值型数据默认初始化为0
            对于布尔型数据默认初始化为false
            对于字符型数据默认初始化为码值为0的字符
            对于引用类型的数据默认初始化为null
        */


        //5.在定义数组时，[]也可以写在数组名的后面
        int ageArr[] = new int[80];     //不建议这样写

        //6.在定义数组的同时，可以给数组的各个元素进行赋值
        int [] arr3 = {12,23,34,45,56};
        /*
            定义了一个数组arr3，这个数组的每个元素是12,23,34,45,56
            这个数组的长度就是初始化时指定的数组元素的个数
        */

        //7.数组有一个length属性表示数组的长度，即数组元素的个数，数组最大下标=长度-1
        System.out.println( "-------------------------------" );
        for ( int i=0 ; i<arr3.length ; i++ ){
            System.out.println( arr3[i] );
        }

        //8.如果遍历某个集合中所有的数据，还可以使用foreach循环
        System.out.println( "-------------------------------" );
        for ( int x : arr3 ){
            System.out.println( x );
        }
        /*
            依次把arr3数组的每一个元素赋值x变量
            在循环体中可以对x变量进行处理
        */

        //9.通过循环修改数组的元素值
        for ( int i=0 ; i<arr3.length ; i++ ){
            arr3[i] = i*i;
        }
        System.out.println( "-------------------------------" );
        for ( int i=0 ; i<arr3.length ; i++ ){
            System.out.println( arr3[i] );
        }

        //10.foreach循环只是用来读取数组的每一个元素，不能用于修改数组的元素值
        for ( int x : arr3 ){
            x = 123;
        }
        for ( int x : arr3 ){
            System.out.println( x );
        }

        System.out.println("Hello World!");
    }
}

• 从键盘上输入n个整数保存到数组中，找出最大数

/*
    从键盘上输入n个整数保存到数组中，找出最大数
*/
import java.util.Scanner;

class Demo19 {
    public static void main(String[] args) {
        //1)从键盘上输入整数的个数，就是数组的长度
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入整数的个数");
        int n = sc.nextInt();

        //2)先定义一个数组
        int [] numArr = new int[n];

        //3)读取数据，保存到数组中
        for ( int i=0 ; i<n ; i++ ){
            System.out.println("请输入第"+(i+1)+"个数");
            //读取之后保存到数组中
            numArr[i] = sc.nextInt();
        }

        //打印数组中的每一个元素
        for ( int x : numArr ){
            System.out.println( x );
        }

        //4)从数组中找最大数
        //先假设索引值为0的元素最大，依次从1的位置开始比较
        int max = numArr[0];
        for ( int i=1 ; i<numArr.length ; i++ ){
            if ( numArr[i]>max ){
                max = numArr[i];
            }
        }
        System.out.println( "最大的数为"+max );
    }
}

• 某个公司采用公用电话传递数据，数据是四位的整数，在传递过程中是加密的，加密规则如下：每位数字都加上5，然后用和除以10的余数代替该数字，再将第一位和第四位交换，第二位和第三位交换

/*
    某个公司采用公用电话传递数据，数据是四位的整数，在传递过程中是加密的，
    加密规则如下：每位数字都加上5，然后用和除以10的余数代替该数字，
    再将第一位和第四位交换，第二位和第三位交换
*/
class Demo20 {
    public static void main(String[] args) {
        int [] data = {3,5,1,8};

        /*
            8,0,6,3
            3,6,0,8
        */

        //每位数字都加上5，然后用和除以10的余数代替该数字
        for ( int i=0 ; i<data.length ; i++ ){
            data[i] = ( data[i] + 5 )%10;
        }

        //将第一位和第四位交换，第二位和第三位交换
        /*
        int t = data[0];
        data[0] = data[3];
        data[3] = t;

        t = data[1];
        data[1] = data[2];
        data[2] = t;
        */
        for ( int i=0 ; i<=1 ; i++ ){
            int t = data[i];
            data[i] = data[data.length-1-i];
            data[data.length-1-i] = t;
        }

        for(int x : data){
            System.out.println(x);
        }
    }
}

• 把一个数组进行逆序

/*
    把一个数组进行逆序
*/
class Demo21 {
    public static void main(String[] args) {
        int [] data = {23,34,45,56,67,78,89,90,01};
        for ( int i=0 ; i<=data.length/2 ; i++ ){
            int t = data[i];
            data[i] = data[data.length-1-i];
            data[data.length-1-i] = t;
        }

        for( int x : data ){
            System.out.println( x );
        }
    }
}

3 Eclipse的使用

1）工作区
2）透视图，显示各个子视图
3）创建项目
在Eclipse中，不能直接创建类，需要先创建项目，在项目中创建类

选择File-new-JavaProject
或者在Package explore面板中，右键，选择new-JavaProject
4）添加类
5）运行
6）设置字号
7）设置文件编码格式
8）设置智能提示
9）添加已有的类
已有的单独的类，可以使用Eclipse打开，打开之后，不能在Eclipse环境中运行，必须把累添加到项目中才能运行，可以把*.java源文件复制粘贴到当前项目中
10）乱码
当前Eclipse的工作区的文件编码格式已经设置为了utf-8,如果java源文件的文件编码格式不是utf-8，就可能产生乱码。

在记事本中打开源文件，选择另存为，在另存为的时候，修改文件编码格式为utf-8，重新复制粘贴到当前项目中
11）添加已有的项目

4 包

4.1 包的定义

1）包是用来管理类的，就类似于使用文件夹管理文件一样

2）常用的系统包：
java.lang Java语言的基础包，这个包系统会自动导入，这个包中的类可以直接使用
java.io Java的IO流类所在的包
java.net 访问网络用到的类
java.util 常用工具类

3）自定义包
可以在源文件的第一条语句，使用package关键字定义包
在Eclipse环境中，定义了包之后，会生成对应的文件夹

package day0602;        //定义包

public class Demo01 {

    public static void main(String[] args) {

        System.out.println("hello eclipse");

    }

}

注意：
1）包名一般使用公司域名的倒序+项目名+模块名
2）如果一个类定义在包中，这个类的完整类名就变为：包名.类名
如：Demo01类的完整类名为：day0602.Demo02

4.2 使用其它包中的类

package com.bjpowermode.day0602.test1;

import java.util.Scanner;           //导入系统类

import day0602.Demo02;              //导入自定义的类

/*
 * 使用其它包中的类，需要通过import先把被使用的类导入到当前文件中
 * */

public class Demo {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        //使用其它包中的类
        Demo02.sMethod();
    }

}