Java入门1

一、eclipse的简单使用

1.新建项目

在package explorer的空白处点击右键，新建一个项目（new->Java Project）或者点击菜单栏的File->JavaProject，然后点击Finish完成。

Project name（项目名称）命名规则：帕斯卡命名规则，只能用下划线，数字，英文字母，数字不能开头。例如HelloWorld1。

帕斯卡命名法：首字母大写，后续所有单词首字母大写，类名，接口，枚举enum适用。

        

2.新建Package

  在新建的Java项目右键new->Java Package，包名处所有字母都小写，网址倒写，com.网址.工程名.包名（例如：com.jredu100.HelloWorld.helloworld）。然后点击Finish完成建包。

       

3.新建Class（类）

  在新建包Package右键new新建一个Class类，类名符合帕斯卡命名规则（帕斯卡命名规则，只能用下划线，数字，英文字母，数字不能开头。），类名用名词不用动词。勾选下图所标注选项可自动创建main方法。

       

4.运行步骤

5.基本输入输出语句

package com.jredu100.lianxi;

import java.util.Scanner;

public class HelloW {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println("请输入");
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();//输入
        System.out.println(n);//输出
    }

}

结果：

二、Java入门知识

1.命名规则

  帕斯卡命名法：首字母大写，后续所有单词首字母大写。类名，接口，枚举enum。

  驼峰法则：首字母小写，后续所有单词首字母大写。方法名，变量名。

  匈牙利法则：所有字母都小写，中间用_隔开。

  项目名称命名：帕斯卡命名规则，只能用下划线，数字，英文字母，数字不能开头。

  Package命名：小写，com.jredu100.helloworld，helloworld项目名。（网址倒写，com.网址.工程名.包名，所有字母都小写。）

  Class命名：帕斯卡命名规则，类名用名词不用动词。

  标识符：字母、数字、下划线、$，不能以数字开头。名字语意直观。类名，变量名，方法名。

　 public、static、class等关键字，被系统所占用，有特殊的含义，不能做命名。

2.8种基本数据类型

整型int	4字节32位有符号整数
长整型long	8字节64位有符号整数
短整型short	2字节16位有符号整数
字节byte	1字节8位有符号整数
字符char	2字节16位Unicode编码
单精度浮点型float	4字节32位浮点数
双精度浮点型double	8字节64位浮点数
布尔boolean	1字节8位

注：char是宽字节码，可以保存一个中文字。

3.基本数据类型的转换

基本数据类型按值传递，传递复本（例如复制的），修改副本不会影响原有的数据。枚举按值传递。 

不同的基本数据类型之间可以进行强制转换，int->long自动转换，long->强制转换，bool不考虑转换。

byte    short

                           int long float double

           char

由高到低-----》》》

自动转换：由低到高，高存储空间可存储小的，可能会浪费存储空间。例：

float f=1.054f;
double d=f;
System.out.println(d);//自动转换

强制类型转化：由高到低，数据类型由高换低，可能造成精度损失。例：

float f=0.1f;//强制类型转换”f“重要
System.out.println(f);

int n3=100;
short s_int2=(short)n3;//类型不匹配 (short)强制类型转换
System.out.println(s_int2);

4.运算符

（1）算术运算符：+ - * / %

//算术运算符
int n=10;
int m=20;
System.out.println(n+m);
System.out.println(n-m);
System.out.println(n*m);
//注意数据类型，如果都是整型，将执行整除运算
//所以结果10/20=0
System.out.println(n/m);
//如果需要转换成float类型的结果则需要进行强制转换

（2）关系运算：== != <  >  >= <=

//关系运算符
//n=0 m=20
//1
System.out.println(n==m);//false
System.out.println(n>m);//false
System.out.println(n<m);//true
System.out.println(n+50>=m);//true
System.out.println(n+20<=m);//true
//2        
boolean isGreate=n>m;//bool型用变量接收
System.out.println(isGreate);

（3）位运算 ： &  |  ^

//按位与&
//现将左右两边的表达式转换成二进制数，分别按每一位进行与操作。
//将与操作的结果的二进制数转换成十进制为最后的结果。
int n=2;        //0010
int m=8;        //1000相与得0000
int n7=n&m;
System.out.println(n7);

//或
int n8=n|m;
System.out.println(n8);    

     
//异或*
int n9=n^m;//取反后相或
System.out.println(n9);

（4）逻辑运算： && ||  !

//逻辑运算符
//  短路与&&
        System.out.println("****************************");
        boolean bool=n>m&&n-10>m;//与，真真才为真
        System.out.println(bool);
        
        bool=n<m&&n+10>m;//真假为假
        System.out.println(bool);
        
        bool=n<m&&n+10<m;//真真为真
        System.out.println(bool);
//&&短路与 两边都为真，结果才为真。
//但如果左边表达式为假，则不再计算右边的表达式，直接返回假（面试）
        

//逻辑或||
//左右两个表达式有一个为真则为真
        
        bool=n>m||n>0;//false
        System.out.println(bool);
        
        bool=n<m||n>0;//true
        System.out.println(bool);
        
//逻辑非！ 又叫取反
//右边的表达式为真结果为假，反之。
        bool=!(n>m);
        System.out.println(bool);

（5）赋值运算：= += -= *= /= %=

//赋值运算符n=11 m=20
        n+=2;
        System.out.println(n);
        
        n-=5;//n=n-5
        System.out.println(n);//8
        
        n*=2;
        System.out.println(n);//16
        
        n/=4;
        System.out.println(n);//4
        
        n%=2;
        System.out.println(n);//0

（6）单目运算：++ --

int n4=n++;//先赋值后自增
System.out.println(n4);
        
int n5=++n;//n++后n5为12
System.out.println(n5);
        
int n6=--n;
System.out.println(n6);
        

（7）多目运算（三元）：min=(a<b)?a:b

//三元运算符（三木、 条件运算符）
//格式：表达式1？值1：值2
//如果表达式1结果为真取值1，如果表达式为假，取值2
        
 int n=2;
 int m=3;
 int n10=n==m?9:10;
 System.out.println(n9);

（8）位移运算符<<带符号左移 >>带符号右移 >>>无号右移

5.变量

变量：是一个暂时性的存储。

（1）声明（2）赋值（3）使用

int n;//声明
n=10;//赋值
System.out.println(n);//使用

常量声明：程序运行过程中不可修改。

//程序中的常量
        
//封装变化
//float pi=3.14f;
//pi=3.1415f;
        
//声明常量需要用final来进行修饰
//常量名所有字母都大写
//常量在程序运行过程中不可被修改
final float PI =3.14f;//例如需要修改圆的个数，则只需改PI
//PI=3.14f;
float area=10*10*PI;
System.out.println(area);
        

练习：

（1）获得会员卡号四位数字

（2）拆分会员卡号的每一位数字

（3）将每位数字进行相加

（4）判断和是否大于20，如果大于20，显示50，否则，显示0。

public class MemberTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        // 1.获得会员卡号四位数字
        System.out.println("请输入会员卡号（四位整数）：");
        //System.in（参数）标准的输入流，控制台输入***
        Scanner sc=new Scanner(System.in);//实例化Scanner对象，console控制台，控制台检索输入流
        int cardID=sc.nextInt();//sc.nextInt从标准输入流读取一个int型的数字
        System.out.println(cardID);
        int qianwei=cardID/1000;
        int baiwei=cardID%1000/100;
        int shiwei=cardID%1000%100/10;
        int gewei=cardID%10;
        //3.将每位数字进行相加
        int sum=qianwei+baiwei+shiwei+gewei;
        int money=sum>20?50:0;
        System.out.println(money);
    }

}

6.包装类型（8个，首字母大写）对应8个基本数据类型

                                               Object

Boolean                                  Number                                 Character

                         Long Short Double Float Integer Byte

（1）基本数据类型<->包装类

包装类是引用数据类型，装箱是让值类型转变为引用类型，拆箱让引用类型转变为值类型。

JAVA里有8种包装类，分别对应8种数据类型

基本数据类型是值类型，包装类是引用数据类型

基本数据类型转成包装类，即值类型转成引用数据类型称为装箱。

//装箱
int m=20;
Integer num2=new Integer(m);
boolean bool1=true;
Boolean bool3=new  Boolean(bool1);

包装类转成基本数据类型，即引用数据类型转成值类型称为拆箱。

//相当于int num=10值类型
//创建对象需要用到new关键字
//语法格式是类名 对象名=new 类名（参数）;
Integer num=new Integer(10);//引用类型
//引用数据类型 new了一个integer的num对象
//可以通过.语法来调用对象的方法
//下面这行代码是要获取对象的int型的值
int n=num.intValue();//值类型  由引用转换成值类型拆箱
        
Boolean bool=new Boolean(true);
boolean bool2=bool.booleanValue();
        
Double dou=new Double(1.555);
Double w=dou.doubleValue();

7.字符串<->基本数据类型

 (1)字符串->基本数据类型

//字符串转成基本数据类型
String s="36";//String代表字符串
//***包装类对象.parse***（参数）方法，是将字符串转成基本数据类型***
int n2=Integer.parseInt(s);
        
double d2=Double.parseDouble(s);
        
String b2="false";
boolean b1=Boolean.parseBoolean(b2);
        
String f1="0.1";
float f2=Float.parseFloat(f1);
System.out.println(f2);

(2)字符串<-基本数据类型

String.valueOf();

8.分支与循环

三种基本流程结构：顺序，选择，循环

（1）循环结构

while do-while for foreach

while循环：

while循环（参考工程HelloJava------WhileTest.java)未知循环次数

while（循环条件（符合条件，继续执行；否则，循环退出））{

循环操作（循环被重复操作）

}

package com.jredu100.hellojava;

public class WhileTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int i=0;
        while(i<10){
            System.out.println(i+1+".让每个梦想成为现实");
            i++;
        }
        
    }
}

do while循环：

do {循环操作}while（循环条件）； （参考工程HelloJava------DoWhileTest.java)未知循环次数，先执行一遍，然后去判断。

package com.jredu100.hellojava;

public class DoWhileTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int i=1;
        int sum=0;
        do{
            sum+=i;
            i++;
            
            
        }while(i<=100);
        System.out.println(sum);
    }
}

for循环：

for循环（参考工程HelloJava------ForTest.java)已知循环次数

for（表达式1；表达式2；表达式3）{

循环操作；

}

package com.jredu100.hellojava;

public class ForTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int sum=0;
        for(int i=1;i<=100;i++){
            sum+=i;
        }
        System.out.println(sum);
    }
}

（2）跳转语句

break,continue, return

1.break结束本层循环，继续执行循环后面的语句，嵌套循环break往外跳一层。

2.continue 结束本次循环剩余的语句，继续执行下一次循环,continue作用于while循环时，必须将变量更新语句放到continue上面，否则将造成死循环。

3.return直接结束当前方法main，遇到return后方法中的所有代码将不再执行。

for( int i=1;i<20;i++){
    if(i%3==0){
    continue;
    }
    System.out.println(i);
}

for( int i=1;i<20;i++){
    if(i%3==0){
    break;
    }
    System.out.println(i);
}
for( int i=1;i<20;i++){
    if(i%3==0){
    return;
    }
    System.out.println(i);
}

（3）选择语句

if else语句

int n1=20;
int m1=30;
if(n1>m1&&n1>20){
    System.out.println(n1);
        }else if(m1>n1){
    System.out.println(m1);
        }else{
    System.out.println("相等");
}        

switch语句

package com.jredu100.hellojava;

import java.util.Scanner;

public class SwitchTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println("请输入你要购买的商品编号：");
        Scanner sc=new Scanner(System.in);
        int userNum=sc.nextInt();
        //1.绿茶，3块钱
        //2.冰红茶，3块钱
        //3.脉动，5块钱
        //4.咖啡，6块钱
        //5.酸奶，5块钱
        switch (userNum) {//switch case 用作相等分支
        case 1://case的值匹配表达式的结果
            System.out.println("1.绿茶，3块钱");
            break;
        case 2:
            System.out.println("2.冰红茶，3块钱");
            break;
        case 3:
            System.out.println("3.脉动，5块钱");
            break;
        case 4:
            System.out.println("4.咖啡，6块钱");
            break;
        case 5:
        case 6:
            System.out.println("5.酸奶，5块钱");
            break;
            
        default:
            System.out.println("无此商品");
            break;
        }
    }

}

9.数组

数组是一组变量集合，存储相同数据类型的一组数据，开辟一块连续的区间。

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

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

数组名：即标识符，连续的空间首地址。表示连续空间的首地址，通过首地址可以依次访问数组所有元素。

以下代码分情况说明，利用注释解决。

package com.jredu100.helloday4;

import java.util.Scanner;

public class ShuZu {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        /**
         * 1.数组：在内存中开辟的一串用于存储相同数据类型的连续空间
         * 2.数组名：表示连续空间的首地址，通过首地址可以依次访问数组所有元素
         * 3.下标：元素在数组中的排序叫做下标，从0开始。
         * 【数组的声明】
         * 1.声明数组：int []arr;
         * 2.给数组分配空间：arr=new int [5];
         * 3.给数组赋值：arr[0]=1;arr[1]=2;
         * 4.访问数组数据，使用数组下标访问
         * 5.数组长度一旦声明将不可改变不可追加
         * 6.数组声明缩写
         *     int[] arr={1,2,3,4,5};//自动分配五个空间*****最常用的声明
         *    int []arr=new int[]{1,2,3,4,5};//[]里不能加数字,不能放内存大小
         */
//        int [] arr;//声明一个int类型的数组//int srr[]=new int[];
//        arr=new int [5];
//        arr[0]=1;
//        arr[1]=2;
//        System.out.println(arr[4]);
        
        
        //int[] arr={1,2,3,4,5};//自动分配五个空间
        //int []arr=new int[]{1,2,3,4,5};//[]里不能加数字
        
        
        /**
         * 使用循环遍历给数组赋值，输出数组
         */Scanner in=new Scanner(System.in);
        int [] arr=new int[5];
        for(int i=0;i<arr.length;i++){
            System.out.println("请输入数组的第"+(i+1)+"个值");
            arr[i]=in.nextInt();
//            System.out.println(arr[i]);//放在这输一遍打印一遍
        }
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }

}

下标：元素在数组中的排序叫做下标，从0开始。

int [] arr;

int arr[];

int [] infoZhang=new int[]{70,60}

int infoLi=infoZhang;

对引用数据类型，复制就是把原对象的地址传递给下一个变量。

 

 

 

总练习：

需求描述：假设一个简单的ATM机的取款过程为：
首先提示用户输入密码（password），假设默认密码为111111，最多只能输入3次，
超过3次则提示用户“密码错误，请取卡”，结束交易。

如果用户密码正确，再提示用户选择金额（amount），
“请输入0到6中任意数字选择对应钱数：0à手动输入金额,1.100元, 2.300元,
3.500元, 4.1000元, 5.3000元, 6.5000元”。

输入数字如果错误，提示“输入错误，是否继续 Y/N”，选择Y重新提示输入钱数编号，
选择N提示“输入错误，请取卡！”。选择数字为1到6，打印对应钱数，
并提示“是否继续 Y/N”。选择数字0，ATM机只能输出100元纸币，
自定义钱数要求最低为100元，最高为1000元。如果用户输入的金额符合上述要求，
则打印输出用户取的钱数，并提示“取款完成，是否继续Y/N”；否则输出一句话“金额错误，
是否继续 Y/N”,如果用户输入Y，提示用户重新选择取款金额，如果用户输入 N，
打印“交易取消，请取卡！”

ps：取款成功后，应该提示用户是否继续，总取款金额不能超过2万


 【解题思路】
 1、验证密码
 ① 密码正确，继续执行下面操作；
 ② 密码错误3次，return；
 2、取款操作。全部包含在 while循环内部。
 ① 提示选择编号；
 ② 根据编号，给money赋值。用switch结构实现。
1~6：直接给money赋固定值，0：手动赋值操作；
 ③ 验证取款是否成功。money-本次取款金额，moneySum-本次取款之前的总金额
 判断moneySum+money是否>20000,3种情况:
 >2000 本次取款超额，但moneySum之前并不足20000，继续下次循环；
 =2000 取完本次money后，刚好满额。money可以加到sum上，然后return；
 <2000 取完本次money后，仍未上限。money可以加到sum上，继续下次循环。
 ④ 验证是否继续，while-if结构实现，有3种情况：
 Y/y 将小循环break，继续执行取款大循环；
 N/n 直接return，停止所有操作；
 其他 continue，继续执行小循环，重复输入Y/N

package com.jredu.ch03.xunhuan;

import java.util.Scanner;

public class Test07_ATM {
    public static void main(String[] args) {
        
        System.out.println("***************欢迎使用ATM取款业务*****************");
        Scanner in = new Scanner(System.in);
        // ① 密码正确，继续执行下面操作；
        int i;
        for(i=0; i<3; i++){
            System.out.print("请输入密码");
            int pwd = in.nextInt();
            if(pwd == 111111){
                System.out.println("密码输入正确，请取款\n");
                break;
            }
        }
        // ② 密码错误3次，return；
        if(i == 3){
            System.out.println("密码错误三次，请取卡！");
            return;
        }
        int money = 0,moneySum = 0;
        // 取款操作
        while(true){
            money = 0;
            // ① 提示选择编号；
            System.out.println("请输入0到6中任意数字选择对应钱数：0à手动输入金额,1à100元, 2à300元,3à500元, 4à1000元, 5à3000元, 6à5000元");
            int num = in.nextInt();
            
            // ② 根据编号，给money赋值。用switch结构实现。
            // 1~6：直接给money赋固定值，0：手动赋值操作；
            switch (num) {
            case 1:
                money = 100;
                break;
            case 2:
                money = 300;
                break;
            case 3:
                money = 500;
                break;
            case 4:
                money = 1000;
                break;
            case 5:
                money = 3000;
                break;
            case 6:
                money = 5000;
                break;
            case 0:
                System.out.print("请输入您的取款金额：");
                int n = in.nextInt();
                if(n>=100 && n<=1000 && n%100==0){
                    money = n;
                }else{
                    System.out.println("金额有误！只能输入100-1000之间的整数。");
                }
                break;
            default:
                System.out.println("编号输入有误！请重新输入！");
                break;
            }
            
            // 验证取款是否成功。money-本次取款金额，moneySum-本次取款之前的总金额
            // 判断moneySum+money是否>20000,3种情况:
            //  >2000 本次取款超额，但moneySum之前并不足20000，继续下次循环；
            //  =2000 取完本次money后，刚好满额。money可以加到sum上，然后return；
            //  <2000 取完本次money后，仍未上限。money可以加到sum上，继续下次循环。
            if(money>0 && moneySum + money > 20000){
                System.out.println("取款失败！取款上限20000元，您还可取款"+(20000-moneySum)+"元");
            }else if(money>0 && moneySum + money == 20000){
                moneySum += money;
                System.out.println("取款成功！本次取款"+money+"元，共取款20000元！今日取款已达上限，请取卡！");
                return;
            }else if(money>0 && moneySum + money < 20000){
                moneySum += money;
                System.out.println("取款成功！本次取款"+money+"元，共取款"+moneySum+"元。还可取款"+(20000-moneySum)+"元");
            }
            
            // 验证是否继续，while-if结构实现，有3种情况：
            while(true){
                System.out.print("是否继续(Y/N):");
                char c = in.next().charAt(0);
                if(c == 'y' || c == 'Y'){
                    break;
                }else if(c == 'n' || c == 'N'){
                    System.out.println("系统退出！请取卡！");
                    return;
                }else{
                    System.out.print("输入有误！");
                }
            }
            
        }