一、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=;
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
//
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; //
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);// n*=2;
System.out.println(n);// n/=4;
System.out.println(n);// n%=2;
System.out.println(n);//
（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("输入有误！");
}
}
}