py-03-JAVASE_随笔_内存溢出

py-03-JAVASE 目录：

该文件寻贴主得

Day01 2.JAVA发展史

1991 – 产生 OAK、

1995 – 产生JAVA

1996 – JDK1.0

1998 -JDK1.2 - 变化

将java分为J2EE,J2SE,J2ME

---J2SE（Standard Edition）：标准版，适用于普通应用程序的开发；

---J2EE（Enterprise Edition）：企业版，适用于大型企业级应用程序的开发；

---J2ME（Micro Edition）：微型版，适用于移动设备或嵌入式设备的程序开发。

2002 – JDK1.4

2004 – JDK1.5

2006 –JDK1.6

2009 – 被Oracle收购

2011 – JDK1.7

2014 – JDK1.8

2017 – JDK1.9

跨平台（ *** 作系统）

3. JAVA运行机制

先编译后运行（解释执行）

4. JAVA环境变量的搭建 1.下载JDK oracle 2.安装JDK

C：Program File..javajdk1.8.0.1

C:Program File..javajre1.8.0.1

3.配置环境变量

变量名称：

JAVA_HOME:JDK文件夹的安装路径

-C:Program FilesJavajdk1.8.0_65

path:jdk下bin文件夹的路径

%JAVA_HOME%bin

测试java环境是否已经搭建好：

java -version

用记事本写一个java程序

java代码的写法结构：

类：类名首字母大写，如果由多个单词组成，每个单词的首字母大写

eg: Test HelloWorld

方法：

代码的实现

public class 类名{

public static void main(String[] args){

代码实现

}

写一个.java程序，程序运行步骤：

1. 写.java程序

2. javac HelloWorld.java 命令编译文件

3. java HelloWorld运行程序

问题：

为什么javac后加的是文件名.java，而java后加的是文件名,不用加后缀？

Ÿ 3.1 JDK,JRE,JVM

JDK:java Developement Kit

JRE:java Runtime Environment

JDK包含了JRE，JRE包含JVM

JVM：java virtual Machine：java虚拟机

java程序其实是运行在JVM上的

Ÿ 3.2 Eclipse工具 – IDE：Integrated Development Environment ：所谓集成开发环境

注意点：在安装Eclipse之前，必须先安装java环境（JDK）

写代码步骤：

1. 创建项目 project

2. 创建包命名规范：域名反写+项目名称+包的功能

a) cn.tedu.day01.pen

b) 快捷键：ALT+/

java中的注释问题：

//:单行注释

文档注释

加单行注释快捷方式：

选中多行，Ctrl+/添加注释，再次Ctrl+/去除注释

加多行注释快捷方式：

选中多行，Ctrl+Shift+/ 添加注释

去除多行注释：

Ctrl+Shift+

2.JAVA变量

什么是变量？

在jvm内存中开辟一块空间，用于保存内容可变的量

变量是用来保存数据的。保存的数据是可变的。

public class Demo01 {
public static void main(String[] args) {
int i = 3;  //=赋值
int a = 5;
//进行加法运算
int sum = i+a;
System.out.println(sum);
}
}

变量的声明

格式：

数据类型变量名；

int a;

变量名的命名规则：

1. 由字母，数字，_，$组成的，数字不能开头

2. 尽可能做到见名知意

3. 如果由一个单词组成，变量名字母都小写，如果变量名是由多个单词组成，第一个单词的首字母小写，除此之外，其他单词的首字母都要大写。

a) 驼峰命名法

b) int studentAge = 4;

4. 中文可以使用，但是不建议使用

5. 变量名不能使用java关键字

6. java中严格区分大小写

变量的初始化:给变量第一次赋值

a = 4;

变量的访问（使用）

1. 赋值

2. 取值

注意点：

在同一方法中，变量名不允许重复

但是在不同方法中，变量名重复是允许的。

int x = 4;

int x = 5; //编译报错

练习题：下面代码正确吗？

int 123go = 100；

int 成绩 = 60；

int break= 200；

int score = 80；

System.out.println(Score)；

5.JAVA基本数据类型

Ÿ 5.1 8种基本数据类型

整数类型：byte short int long

浮点类型: float double

字符型: char

布尔类型：boolean

整数类型以及各自占用的空间大小

整数类型不同，所能表示的数值范围是不同的。

内存大小值的范围

byte 1个字节 8位 -2^7 ~2^7-1 =-128~127

short 2个字节 16位 -2^15~2^15-1=-32768~32767

int 4个字节 32位 -2^31~2^31-1= -2147483648 ~ 2147483647

long 8个字节 64位 -2^63~2^63-1=-9223372036854775808~9223372036854775807

byte:

-128-127

byte b = 127;

byte b = 128; //数据溢出

int:

-2147483648 - 2147483647

int i = 100;

int i = 10000000000;

保存数据时，需要注意数据溢出

整数直接量（字面量）：

可以是八进制，十进制，十六进制

int i = 3;

八进制：0-7 067 int a = 067;

十六进制：0-9 a b c d e f

int x = 0x9af3;

计算机所识别的语言只有机器语言，即只认识二进制 0 1

int类型的整数转换为二进制

10 转换为进制后的表示是32个0,1组成

整数的二进制表示0000 0000 0000 0000 0000 0000 0000 0111

8421

整数的十六进制表示： 0x2a3e41ff

二进制：权重

每一位上对应的权重 2^n(n>=0)

为了缩写二进制，产生了十六进制

十六进制表示的就是二进制数

二进制和十进制的转换

二进制-->十进制

0111 1010 0110 1111

每一位上的值*权重，最后权重相加求和，这个和就是十进制的表示

十进制-->二进制：

十进制数÷2取余，最后余数倒置

求25的二进制表示：

11001

练习题：

0111 1010 0110 1111

0x7a6f

整数相除：

注意点：如果两个整数相除，二者除不尽，此时进行取整 *** 作（不是四舍五入）

eg: 1.9 取整 1

1.1 取整 1

long类型:长整型

赋值：long l = 4L/l;

给long类型变量赋值时，一定要在值的后面+L/l

注意点：数据溢出

浮点型：小数

内存大小

float 4个字节

double 8个字节

浮点型内存大小占用不同，体现在类型所能表示的精度是不同的。

float：单精度浮点数

double:双精度浮点数

精度问题：

float:单精度，7/8位有效数字

double：双精度，15/16位有效数字

float f = 34.12345678;

最终保存在内存中为：3.412345E1

给float类型的变量赋值：值+F/f

java中写出一个浮点数，默认是double类型

自己看的内容（不做要求）:

----------------------------------------------------

Float和double类型精度问题：

Double和Float在计算机中都是以科学计数法保存数据的。

eg:3.13445 是以3.13445E1 即3.13445*10^1的形式保存的

float:4个字节，32位，在这 32 bit 中，

- 1个bit表示符号位， - 8个bit表示指数位， - 剩下的23个bit是有效数字位。

- 2的23次方是8388608，即7位十进制有效数字。按照这个表示方法转化成10进制之后，它能表示的最高精度是7位有效数字。

float : 1位符号位， 8位指数位，23位尾数位

double: 1位符号位，11位指数位，52位尾数位

float ：尾数位23位，2^23=8.3E6，7位，不同的编译器规定不同，有些是7位，有些8位

double：尾数52位，2^52=4.5E15，16位，所以double的有效位数是16位，编译器不同，有些是15位，有些是16位

----------------------------------------

赋值举例精度保存

double d = 3.123456678987657899;

System.out.println(f);

double类型数据进行运算会出现精度问题：

double类型数据进行运算时有可能会出现不精确的结果，所以，double类型数据不进行精确运算。

- BigDecimal

char类型：字符型：0-65535

char类型占用2个字节

char c = 'a';

在内存中存储的形式：整型数字

Unicode编码：

一个数字对应一个字符，字符包括英文，包括中文，日文，韩文。。。。

版本3:65535个字符

版本8:10万+

给char类型的变量赋值：

字符

整数

十进制，十六进制

Unicode编码值

u9af5

char c = 'a';
char c1 = 98; // -
System.out.println(c1);
char c2 = 'u4e00';
System.out.println(c2);

常见整数与之对应的字符：

97 - a

65 - A

布尔类型：boolean

true false

boolean b = true;

通常用于判断

eg:

int a = 4,b = 5;

判断a，b的大小

boolean flag = a>b;

知识点梳理：

1. java运行机制（跨平台）

2. java环境的搭建

3. JDK,JRE,JVM

4. 变量

a) 变量的声明

变量的初始化：

1. 先声明，后初始化

2. 在声明的同时进行初始化

变量的使用：

赋值取值

5. java中8中基本数据类

a) 整数类型：byte,short,int,long;

b) 浮点类型: float ,double;

c) 字符类型:char

char 2个字节

char保存在内存中是unicode编码

char直接量

a) ‘’

b)整数

c) unicode编码u16进制的数字

d) 布尔类型：boolean

值：true false

Ÿ 5.2 类型转换

Ÿ 5.3 不同类型间的数据运算

byte，short，char三种类型参与运算时，先一律转换成int类型再进行运算

其他类型间运算，如果类型不同，那么先提升类型，后进行运算

- 注意点：运算过程中的数据溢出

- eg:

- long distance1 = 10000 * 365 * 24 * 299792458L;

- long distance2 = 10000 * 365 * 24 * 299792458;

6.练习题

int a = 6;

float f = a;

System.out.println(f); f=?

byte b = 9;

char c = b;

System.out.println(c); c=?

double d = b;

System.out.println(d); d=?

int i=1,j=2;

j = j+10;

i = i/10;

i = i*0.1;

byte b1 =1,b2 = 2,b3 = 129;

byte b = b2-b1;

char c1 = ‘a’, c2 = 125;

char c = c1+c2-1;

float f1 = 0.1, f2 = 123;

float f3 = f1+f2*0.1;

7. 作业

1.搭建JAVA环境并在Eclipse中实现JAVA HelloWorld

2.指出下面程序中的编译错误，并更正

int length = 10;

System.out.println(lenght);

int &size = 20;

System.out.println(&size);

int age;

System.out.println(age)

int balance;

balance = 218.50;

byte b1 = 10;

byte b2 = 20;

byte b3 = b1+b2;

int i = 128;

i = 10000000008;

System.out.println(i);

3.指出下面程序的运行结果

int count = 30;

count = 60;

System.out.println(count)；

double width = 6.0;

double length = 4.9;

System.out.println(width-length);

char ascii = 98;

System.out.println(ascii);

Day02 1.内容回顾：

java发展史

java运行机制

变量：

变量的声明

数据类型变量名；

变量名的命名规则

变量的初始化:

第一次赋值

2种写法：

1. 先声明，后初始化

2. 在声明的同时进行初始化

3. 注意点：

只声明，没有初始化，不可以使用

变量的使用：

赋值

取值

java提供了8种基本数据类型：

整数类型：byte short int long

浮点类型:float double

字符类型:char

布尔类型:boolean

2.基本数据类型间的转换问题：

long l = 12;

隐式转换（自动转换）小转大，自动转

boolean类型和其他数据类型都是不兼容的

char -->int

byte-->short--> int--> long--> float-->double

byte b = 12;
short s = b;  //正确的
int i = b;  //正确的
i = s;     //正确的

float f = 3.14; //报错的

大转小，不能自动转：因为有可能会造成数据精度丢失或数据溢出

强制转换（显式转换）

long l = 234;
int i = (int)l;

容易出问题的类型转换：
char -->  int  自动转换

char --> byte  强制转换

byte --> char  强制转换

short --> char  强制转换
char -->short   强制转换

3.不同类型间的数据运算

1. 不同数据类型间进行运算，总共分2步：

a) 提升类型

b) 进行运算

注意点：

1. 不同数据类型间进行运算，最终结果类型和最高类型一致，

2.如果表达式是由多个（>2）多个变量进行运算，存在多次类型提升.

3.注意运算过程中的数据溢出

4. byte ,short ,char类型间进行运算，都会先全部转换为int类型，再进行运算，运算结果一定是int类型。

5. char类型可以自动转换成int--> long--> float-->double的类型，但是char不能转换成byte—>short的类型。

eg:

long distance1 = 10000 * 365 * 24 * 299792458L; //正确

long distance2 = 10000 * 365 * 24 * 299792458;

//数据溢出；此运算都是int类型相乘在编译器不报错，但是结果超出了int的最大值所以发生溢出。

2.byte，short，char三种类型参与运算时，先一律转换成int类型再进行运算

byte + byte -- >int

byte + short -- >int

char + char -->int

导致的结果：

byte b1 = 1,b2 = 3;

byte b3 = b1+b2; //报错的

注意点：

byte b1 = 1,b2 = 3;

byte b3 = b1+b2; //报错的；变量在编译期找不到其值，值在内存中，所以报错

byte b4 = 1+3; //正确的；编译器在此做了优化

原因：

1、而如果是变量，编译器是不知道该变量的值，变量的值保存在内存中，运行的时候才能找到其值，编译期找不到其值所以无法优化，所以报错。

2、如果是整数直接量进行运算，编译器在编译期会进行类型优化。

public class Demo02 {
public static void main(String[] args) {
int a = 12;
long l = 234;
double d = 3.14;

double result = a+l+d;




long distance1 = 10000 * 365 * 24 * 299792458L;
System.out.println(distance1);


long distance2 = 10000 * 365 * 24 * 299792458;
System.out.println(distance2);


int i = 129;
byte by = (byte)i;


System.out.println(by);//－127


byte b1 = 12;
byte b2 = 1;


//    byte res = b1+b2;
byte res = 12+1;

System.out.println(res);

}

}

练习题

int a = 6;

float f = a;

System.out.println(f); f=?

byte b = 9;

char c = b; //报错的；因为byte,short,int 类型都有复数，而char的取之:0~65535之间

System.out.println(c); c=?

double d = b;

System.out.println(d); d=?

int i=1,j=2;

j = j+10;

i = i/10;

i = i*0.1; //编译错的

byte b1 =1,b2 = 2,b3 = 129; //编译错误

byte b = b2-b1; //编译错误

char c1 = ‘a’, c2 = 125;

char c = c1+c2-1; //编译错误

float f1 = 0.1, f2 = 123; //f1编译错误；float类型的数后面要加f;如：0.1f

float f3 = f1+f2*0.1;

类型转换

隐式转换（自动转换）：小转大，自动转

强制转换（显式转换）：大转小，强制转（要转换成类型）

char类型和byte，short间转换也得强制换

不同数据类型间进行运算：

1. 分2步：类型提升，再进行运算

a) 注意点：

<1>最终结果类型和最高类型一致

<2>多个变量进行运算，存在多次类型提升

<3>需要注意数据溢出

2. byte ,short ,char类型间进行运算，都会先全部转换为int类型，再进行运算，运算结果一定是int类型。

a) byte b1=2,b2=3; b1 = b1+b2; 编译错误

b) b1 = 1+2;

4.运算符和表达式算数运算符:

+ - * / %(模运算)取余 ++ --

int a=8,b=5;

int c = a%b; //c就是a/b的余数

++ 自增：变量本身的值自行增加1

++可以放在变量之后，也可以放在变量之前。++和变量的前后位置不同，效果是不同

即 i++ ++i

如果++在变量之后， i++ ：先赋值，后运算

如果++在变量之前，++i：先运算，后赋值

int x = 9,y=10;
int result = x++ + ++y + --y;



System.out.println(result);  //30

关系运算符：

< > >= <= == !=:不等于

int a = 5,b=5;

a==b - boolean

a!=b - boolean

练习：定义2个变量，判断二者是否相等，是否不等

关系运算符应用于表达式值，会返回一个boolean的值。

逻辑运算符：

&& ：与运算（and运算）

用法：

boolean result= 表达式1（boolean） && 表达式2（boolean）；

boolean flag = 3>5 && 12<23;

result

表达式1

表达式2

true

false

true

false

true

false

int a=3,b=5,c=9;
boolean flag = a+b==c && a 
|| :逻辑或运算 
  用法： 
     
boolean  = 表达式1（boolean）|| 表达式2(boolean） 
||两边的表达式只要有一方的结果为true，那么结果就为true 
 
规则： 
 result    
  表达式1
  表达式2
  true      
  true
  true
  true      
  true
  false
  true      
  false
  true
  false
  false
  false 
练习： 
    int a = 8,b=2; 
    boolean flag = a%b==0 || b%a!=0; 
    flag : true 
 
！:非运算:取反 
    用法：  boolean result = !表达式（boolean）; 
 
逻辑运算符中的短路问题： 
    &&   ||  ：分别又叫做  短路与   短路或 
    非短路与  &   非短路或   | 
 
    执行机制： 
       boolean result = 3>5  &  10<12; 
       boolean result = 3>5  &&  10<12; 
 
       boolean result = 3<5  | 10<12; 
       boolean result = 3<5 || 10<12; 
 
练习题： 
       1.int i = 100, j = 200; 
boolean b1 = (i > j) && (i++ > 100); 
System.out.println(b1);  
System.out.println(i); 
boolean b2 = i > 0 || j++ > 200; 
System.out.println(b2); 
System.out.println(j);  
 
3.  接收用户输入的一个年龄，判断是否在18到50之间。 
a)   如何接受用户从控制台输入的内容 
                  <1>创建Scanner类对象 
                  <2>调用该类下的nextInt()方法接受用户输入的int类型数据 
Ø  nextInt() - int(返回值) 
//1.创建Scanner类对象
Scanner sc = new Scanner(System.in);
System.out.println("请输入年龄：");
//2.接受用户从控制台输入的int类型的值
int input = sc.nextInt();
//对接受到的年龄进行判断 18-50
boolean flag = input>=18 && input<=50;
System.out.println(flag);
sc.close(); 
   Scanner类方法学习： 
       nextInt() - int 
       nextDouble() - double 
       nextFloat() - float 
       .. 
       next() - String 
       nextLine() - String：读取一行数据 
    注意点： 
       在使用next系列方法时，nextLine方法 
        * 不要和next(),nextInt...这些方法一起使用 
        * 要么都用nextLine() 
        * 要么都用其他next方法，不用nextLine（）       
 
赋值运算符： 
    =  +=  -=   *=  /=   %= 
           
    +=     a+=b     a=a+b 
 
    -=     a-=b     a=a-b 
 
    *=     a*=b     a=a*b 
 
    /=     a/=b     a=a/b 
 
    %=     a%=b     a=a%b 
 
注意点： 
    += 系列扩展赋值运算符具有强转功能。 
byte b = 12;
int a = 5;
//    b = b+a;   //编译错误
b += a;    //编译正确，扩展赋值运算符具有强转功能
System.out.println(b); 
字符串连接运算符：  + 
    String str = "abc"; 
    String str1 = "def"; 
    str1 = str+str1; 
 
+是哪种运算符的判断方式： 
    如果+两边连接的是数值类型，那么此时就是算术运算符 
    如果+两边只要有一边是String类型，此时就是字符串连接运算符 
注意点： 
    当有多个部分的内容进行+ *** 作时，必须是一步一步进行运算的，运算过程中+的作用取决于+两端的类型。 
String str = "abc",str1 = "def";
//将两个字符串连接成一个新的字符串
String dest = str+str1;
System.out.println(dest);

System.out.println(2+str);

System.out.println(3+5+"a");  //8a
System.out.println("a"+3+5);  //a35 
三目运算： 
    用法： 
    数据类型 s=表达式1(boolean)？表达式2：表达式3； 
    
    String s = 3>5?"成立":"不成立"； 
 
    注意点： 
       表达式2和表达式3 的返回类型必须是相同。 
 
    练习： 
       用三目运算判断一个数字是正数还是负数（不考虑0） 
//用户输入值
//    Scanner sc = new Scanner(System.in);
//    System.out.println("请输入一个整数：");
//    int value = sc.nextInt();
//    //对输入的值进行正负数判断
//    String message = value>0?"正数":"负数";
//    System.out.println(message);
//    sc.close(); 
 三目运算的嵌套：正负数0的判断 
//用户输入值
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数：");
int value = sc.nextInt();
//对输入的值进行正负数0判断
String message =
value>0?"正数":(value==0?"0":"负数");
System.out.println(message);
sc.close(); 
知识点总结： 
1.  数据类型转换问题 
        a)   自动转换（隐式转换） 
        b)   强制转换（显式转换） 
2.  不同数据类型间运算问题 
        a)   不同类型进行运算， 
                   <1>分2步  ①类型提升 ②运算 
                   <2>运算过程中数据溢出 
                   <3>结果的类型和表达式中的最高类型一致 
        b)   byte short char类型间进行运算，会先都转换为int类型，再进行运算，运算的结果是int类型 
                    <1>byte b1=1,b2=2; 
                   <2>byte b3 = b1+b2;  //编译错误 
                   <3>byte b4 = 1+2;  //正确的 
3.  运算符和表达式 
        a)   算术运算符 
        b)   关系运算符 
        c)   逻辑运算符 
        d)   赋值运算符 
        e)   字符串连接运算符 
        f)   三目运算  
作业：  
1.接收用户输入的一个年份，判断这个年份是否为闰年。 
       注：闰年的判断公式为：  年份能被4整除，且不能被100整除的是闰年或者年份能被400整除的是闰年。 - 三目 
2.System.out.println(5+6+””+5+6); 
3.用户从控制台接受两个整数，通过程序找出两个书中的最大值（三目运算）。 
4.  收银台收款程序，输入单价，数量，计算出总价和找零  --- 保留小数问题 

Day03 
1.内容回顾： 
运算符和表达式 
    算术运算符 
    关系运算符 
    逻辑运算符 
    字符串连接运算符 
    赋值运算符 
    三目运算 
 
练习： 
收银台收款程序，输入单价，数量，计算出总价和找零  --- 保留小数问题 
public static void main(String[] args) {
System.out.println("请输入购买的商品的单价：");
Scanner sc = new Scanner(System.in);
double singPrice = sc.nextDouble();
System.out.println("请输入购买的数量：");
int count = sc.nextInt();
double total = singPrice*count;
//对total进行保留小数并展示给用户
DecimalFormat format = new 
DecimalFormat("#0.00");
String totalStr = format.format(total);
System.out.println("应付金额为："+totalStr);
System.out.println("请付款：");

double pay = sc.nextDouble();

//找零
if(pay>=total){
double minus = pay-total;
String minusStr = format.format(minus);
System.out.println("找零："+minusStr);
}else{
System.out.println("金额不足！");
}
sc.close(); 
保留小数问题： 
DecimalFormat df = new DecimalFormat("#0.00");
double price =0.3;
String str = df.format(price);
System.out.println(str); 
问题：收银台收款，超过300打95折，超过400打9折，超过500打8折，如何实现？ 
 
2.分支结构 
1.  if..else分支 
if(表达式){ 
    分支语句 
}else if(表达式){ 
    分支语句 
}else if....{ 
 
}else{ 
    分支语句 
} 
 
注意点： 
1.  else不一定非得出现，电视具体情况而定 
2.  else if不一定出现，视具体情况而定 
3.  if分支可以单独使用 
4.  如果某个分支的语句只有一条，此时{}可以省略 
2.  switch..case分支 
        a)   结构： 
switch(表达式/变量/值){ 
    case val: 
       .... 
       break; 
 
    case val1: 
       .... 
       break; 
    .... 
    default: 
       ... 
       break; 
} 
 
  注意点： 
 
1.  break注意点不要丢了 
2.  switch后的()内的数据的数据类型只能是int（byte，short，char），String，enum 
3.  switch分支中最后一条分支即default分支，如果情景不需要，可以不写的。 
两种分支结构的对比： 
     if..else分支通常用于做范围判断 
     switch分支通常用于做准确值匹配    
案例： 
收银台收款，超过500打八折、 
若收款金额大于等于应收金额，则计算找零后输出；若收款金额小于应收金额，输出错误提示信息。 
根据学生成绩输出等级 
 
3.循环结构 
问题：输出10次hello 
循环是程序设计语言中反复执行某些代码的一种计算机处理过程，是一组相同或相似语句被有规律的重复性执行 
 
4.Java中的循环结构 
while循环 
结构 
    while(表达式-boolean){ 
       循环体 
} 
重点： 
    判断条件 
    循环体 
 
案例：输出10次hello 
int i = 0;  //i代表循环次数
while(i<10){
System.out.println("hello");
i++;
} 
练习： 
1.输出1-100之间的所有数字 
2.输出1-100之间所有的偶数 
//    int i = 1;
//    while(i<=100){
//       System.out.println(i);
//       i++;
//    }


int i = 1;
while(i<101){
//偶数判断
if(i%2==0){
System.out.print(i+" ");
}
i++;
} 
1.2 break关键字： 
    break可以用于分支语句，也可以用于循环中 
    作用： 
       break：跳出当前循环 
public static void main(String[] args) {
//对1-10之间的所有数字进行遍历
//输出1-10之间7以前的数字  - 断点
int i = 1;
while(i<11){
System.out.println(i);
if(i==7){
break;
}
i++;
}

} 
练习： 
程序随机生成并存储一个整数（1-100），用户输入一个整数，程序给出与存储的数字“大”或“小”的比较结果提示；直到用户猜对数字为止；如果中途，用户希望结束程序，可以输入0退出。 
 
随机生成整数： 
    Math.random() -   0= 
    随机生成0-99之间的整数（包括0和99） 
           (int)(Math.random()*100) 
           0= 
 
       随机生成1-100之间的整数（包括1,100） 
    (int)(Math.random()*100)+1 
public class GuessNumber {
public static void main(String[] args) {
int destNum = (int)(Math.random()*100)+1;
System.out.println(destNum);
//用户从控制台输入猜测的数字
System.out.println("请输入猜测的数字：如果中途退出，选择0");
Scanner sc = new Scanner(System.in);
int guessNum = sc.nextInt();
//比较
while(guessNum!=destNum){
if(guessNum==0){
System.out.println("即将退出程序！");
break;
}
//比较大小
if(guessNum>destNum){
System.out.println("猜大了，请重新输入！");
}else{
System.out.println("猜小了，请重新输入！");
}
guessNum = sc.nextInt();
}
//判断猜测的数字是否和目标数字相等
if(guessNum==destNum){
System.out.println("恭喜你，答对了！");
}
sc.close();

}

} 
1.3  死循环 
一般情况下，循环 *** 作中会存在使得循环条件不满足的可能性，否则将成为“死循环”。 
换言之，如果一个循环的表达式的值永远为true，这个循环就是一个死循环 
 
while(true){} 
问题： 
    死循环应不应该出现？ 
       视具体情况而定： 
           如果预期结果中没有死循环，那么就不应该出现 
有一些特定的场景，需要用到死循环来实现一些目的。这种情况下，死循环是可以出现的。 
 
do..while循环 
2.1结构： 
    do{ 
       ..循环体 
}while(表达式-boolean)； 
 
特点： 
    循环体至少会执行一次。 
 
区别： 
    while循环：先判断后执行，循环体有可能一次都没有执行 
    do..while循环：先执行后判断，循环体至少执行一次。 
 
练习： 
用户输入密码，如果输入错误，重新输入，直到输入正确，输入正确，给出提示：登录成功! 
public class DoWhileInputPwdDemo {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int pwd;
do{
System.out.println("请输入密码：");
pwd = sc.nextInt();
}while(pwd!=123456);
System.out.println("登录成功！");
sc.close();
}

} 
 
 
for循环 
3.1结构 
    for(表达式1；表达式2；表达式3){ 
       循环体 
} 
 
表达式1：用来对变量进行初始化 
表达式2-boolean :条件判断 
表达式3：控制变量的变化 
 
案例： 
    输出1-10之间的所有数字 
    for(int i=1;i<11;i++){ 
       System.out.println(i); 
} 
 
练习题： 
求1-100得和 
求1-100之间所有的偶数 
//    for(int i=1;i<101;i++){
//       //对i所保存的值进行偶数判断
//       if(i%2==0){
//          System.out.println(i);
//       }
//    }

int sum = 0;  //sum变量保存和
for(int i=1;i<101;i++){
sum += i;
}
System.out.println(sum); 
知识点总结： 
 
1.  分支结构  
     a)   if..else 
     b)   switch..case 
 
2.  循环结构 
     a)   while循环 
     b)   do..while循环 
     c)   for循环 
     d)   break关键字 
6.作业： 
1.写出输出结果 
       2.有数列：9，99，…，9999999999.（10个9）要求使用程序计算此数列的和，并在控制台输出。 
3.求100-1000间的水仙花数  153 
4.  程序依次出10道加法题目，由用户输入题目的答案；用户每答完一道题，程序判断对错，并提示：“答对了”或“答错了”；10道题目答完之后，系统计算得分并输出（每题10分）；若用户希望提前结束，可以输入-1提前退出。 
5.编写个人所得税计算程序 
个人所得税是国家对本国公民，居住在本国境内的个人的所得和境外个人来源于本国的所得征收的一种所得税。目前，北京地区的个人所得税的计算公式是：应纳税额 = （工资薪金所得-扣除数）*适用税率-速算扣除数。   其中，扣除数为3500，使用税率以及速算扣除数如下表所示。 
 全月应纳税所得额
  税率
  速算扣除数（元）
  全月应纳税额不超过1500元
  3%
  0
  全月应纳税额超过1500至4500
  10%
  105
  全月应纳税额超过4500至9000
  20%
  555
  全月应纳税额超过9000至35000
  25%
  1005
  全月应纳税额超过35000至55000
  30%
  2755
  全月应纳税额超过55000至80000
  35%
  5505
  全月应纳税额超过80000
  45%
  13505 
上表中的全月应纳税所得额  = 工资薪金所得 - 扣除数。 
 
本案例要求计算个人所得税的缴纳额度：用户从控制台输入税前工资的金额，程序计算所需要缴纳的个人所得税的金额，并将计算结果输出到控制台。 

Day04 
1.内容回顾 
1.分支结构 
        a)   if..else 
        b)   switch..case 
2.循环结构 
        a)   while循环 
        b)   do..while循环 
        c)   for循环 
3.for循环 
一．注意点：for循环三个表达式特殊用法(4) 
 
      1. 
         int i=0; 
  for(;i<10;i++){循环体} 
2. 
for(int i=1;i<10;){ 
     System.out.println(i); 
     i++; 
} 
3. 
    for(int i=0,j=1;i<10&&j>-5;i++,j--){} 
    注意点： 
表达式2的位置一定是只有一个表达式，返回boolean值 
 
4. 
    for(;;){循环体}    死循环 
public class ForDemo {
public static void main(String[] args) {

//    int i=0;
//    for(;i<10;i++){
//       System.out.println(i);
//    }

//    for(int i=1;i<10;){
//       System.out.println(i);
//       i++;
//    }


//    for(int i=0,j=1;i<10&&j>-5;i++,j--){
//       System.out.println(i);
//       System.out.println(j);
//    }


for(;;){
System.out.println("1");
}
}

} 
二．关键字break,continue 
break：既可以用于分支结构，也可以用于循环结构：跳出当前循环 
continue:只用于循环结构：跳出本次循环，继续下次循环 
public static void main(String[] args) {

//    for(int i=0;i<10;i++){
//       System.out.println(i);
//       if(i==7){
//          break;
//       }
//    }


for(int i=0;i<10;i++){
if(i==7){
continue;
}
System.out.println(i);
}
} 
案例： 
1. 1-100求和，当和>300时跳出循环并输出此时i的值 
2. 1-100求和，统计总和时，跳过所有个位为3的数字 
//    int sum = 0;
//    for(int i=1;i<101;i++){
//       sum += i;
//       if(sum>300){
//          System.out.println(i);
//          break;
//       }
//    }
//    System.out.println(sum);


int sum = 0;
for(int i=1;i<101;i++){
if(i%10==3){
continue;
}
sum += i;
}
System.out.println(sum); 
三．循环问题 
循环语句的选择： 
    如果是固定次数的循环，优先选择for循 
    如果次数不固定，在while，do..while中选择 
    while和do..while的选择： 
       逻辑判断，分析出循环是要先判断还是先执行 
 
四．循环嵌套 
1.打印九九乘法表 
  9行，每行的列数取决于行数的 
2.用*打印四行四列的正方形 
* * * * 
* * * * 
* * * * 
* * * * 
3.输出2-100之间所有的质数 
质数：从2开始，某一个数字如果只能被1和它本身整除，这个数字就是质数，如 2 3 5 7 11.。。。 
public class Demo01 {
public static void main(String[] args) {

//i代表行号
for(int i=1;i<10;i++){
//j代表列
for(int j=1;j<=i;j++){
System.out.print(i+"*"+j+"="+i*j+"t");
}
System.out.println();
}
}
}


public class Demo03 {
public static void main(String[] args) {
//i代表2-100之间的每一个数字
for(int i=2;i<=100;i++){
int count = 0;
//对此时i的值进行质数判断
//j代表除数：从2开始到i为止
for(int j=2;j<=i;j++){
//判断是否能整除
if(i%j==0){
count++;
}
}
if(count==1){
System.out.print(i+" ");
}
}
}

} 
循环总结： 
    1.3种循环结构 
    2.break,continue关键字 
    3.循环选择问题 
    4.循环嵌套 
2.数组 
JAVA中，程序 = 算法 + 数据结构； 
前面学习的if、if-else、switch、循环解决的都是流程问题，即算法问题。 
所谓数据结构，简单说就是把数据按照特定的某种结构来保存，设计合理的数据结构是解决问题的前提。数组就是最基本的一种数据结构。 
 
2.1什么是数组： 
       数组是多个相同类型数据的组合，实现对这些数据的统一管理 
    10个int/double/String..数据，如果这些数据想保存起来，此时就可以用数组了 
2.2数组的定义： 
        保存10个int类型的数据，此时如果用数组的话，我们需要创建一个数组、 
                           int[] ary = new int[10];       
   
        数组的声明： 
              数据类型[] 数组名; 
              数据类型 数组名[]; 
 
               int[] ary; 
               int ary[]; 
       数组的初始化:3种方式 
1.  int[] ary = new int[3]; 
          a)   如果数组采用这种方式创建，那么在数组创建好后根据元素的数据类型会进行默认初始化 
                       默认值：根据数据类型决定 
               int: 0 
               double :0.0 
               boolean:false 
               char:u0000 
               String:null 
 
2.  在声明的同时直接给定具体值 
               a)   int[] ary = {1,23,45,6}; 
3.  int[] ary = new int[]{1,2,3,4}; 
       数组的访问： 
              访问长度: 
                     ary.length; - int 
               访问元素： 
                    通过下标（索引）来访问的。 
数组的线性特性 – 有序： 
       所谓线性顺序是指除第一个元素外，每一个元素都有唯一的前驱元素；除最后一个元素外，每一个元素都有唯一的后     
继元素（“一个跟一个”） 
可以通过元素所在位置的顺序号（下标）做标识来访问每一个元素（下标从0开始，最大到元素个数-1） 
//    int[] ary = new int[3];
//    System.out.println(Arrays.toString(ary));


String[] strArray = {"a","b","c","d"};
System.out.println(Arrays.toString(strArray));


//    double[] doubleArray = new double[]{2.1,3.2};
//    System.out.println(Arrays.toString(doubleArray));
//    System.out.println(doubleArray.length);


String str = strArray[1];
System.out.println(str); 
遍历数组： 
案例： 
遍历数组元素，正序输出 
遍历数组元素，逆序输出 
 
练习： 
       定义一个长度为10的数组，元素随机生成，找出数组中元素的最大值 
 
2.3 数组的复制 
    要求：有2个int数组 
       int[] ary1 = {1,2,3}; 
       int[] ary2 = new int[5]; 
       现要求ary1中1-2下标的元素复制到ary2的0-1位置，如何实现？ 
 
1.System.arrayCopy 
-arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 
       思考：length的值偏小或偏大 
 
2.Arrarys.copyOf() 
    类型[ ]  newArray  = Arrays.copyOf (类型[ ]  original , int  newLength ); 
       特点：生成的新数组是原始数组的副本 
       思考：newLength<原数组长度? 
             newLength > 原数组长度? 
 
数组的扩容 
         练习： 
1.找出数组元素中的最大值并将找出的最大值放在数组最后一个元素的下一个位置。 
2.4数组的排序 
所谓排序，是指将数组元素按照从小到大或从大到小的顺序重新排列； 
对于元素较多的数组，排序算法的优劣至关重要；一般情况下，通过排序过程中数组元素的交换次数来衡量排序算法的优劣； 
常用的排序算法有：冒泡排序、选择排序等。 
 
冒泡排序： 
           - 比较相邻的元素，如果违反最后的排序准则，则交换 
           - 比较时既可以采用"下沉"的方式（降序），也可以采用"上浮"的方式（升序） 
 
    案例： 
1.用冒泡排序将数组中的最大值选出 
       2.对一个数组进行升序排列 
 
选择排序： 
        从0下标开始，依次和后面每个元素比较，小的往前放，第一次完毕，最小值出现在了最小下标处 
 
    案例： 
       1.用选择排序将数组中的最小值选出 
       2.对一个数组进行升序排列 
Arrays.sort(): 
 
3.作业： 
 
数组长度为20，内容为0-9的任意数字，统计每个数字出现的次数。 
有一个长度为20数组，数组中的内容为0，1，实现一次排序，所有的0都排在1之前。（不用排序方法） 
创建一个长度为10的数组，数组内放置10个0-99之间的随机整数作为数组元素。要求查询出数组中的最小值，并打印显示在界面上。然后，将数组的长度扩容为11，将查询到的最小值记录为数组的第一个元素，并打印扩容后的数组的内容 

Day05 
1.内容回顾 
数组： 
    数组的定义： 
       数组的声明： 
           数据类型[] 数组名称； 
           数据类型 数组名称[]; 
       数组的初始化: 
1.  数据类型[] 数组名 = new 数据类型[length]； 
2.  数据类型[] 数组名 = {元素1，元素2...} 
3.  数据类型[] 数组名 = new 数据类型[]{...}; 
 
数组的访问： 
    数组的长度：length 
    数组的元素：通常下标访问   数组名[index] - E 
    
2.数组 
2.1遍历数组： 
int[] ary = {1,2,3};
for(int i=0;i<=ary.length-1;i++){
System.out.println(ary[i])
} 
案例： 
遍历数组元素，正序输出 
遍历数组元素，逆序输出 
 
注意点： 
    在访问数组时，如果访问的下标超过数组的最大下标，那么运行期会报数组下标越界问题。 
 
练习： 
定义一个长度为10的数组(int[])，元素随机生成，找出数组中元素的最大值 
public class MaxValue {
public static void main(String[] args) {
//创建长度为10的int数组
int[] ary = new int[10];
//为数组的每个位置赋值- 是随机生成的int数
for(int i=0;iary[i]?max:ary[i];
}
System.out.println(max);
}

} 
2.2 数组的复制 
    要求：有2个int数组 
       int[] ary1 = {1,2,3}; 
       int[] ary2 = new int[5]; 
 
ary1叫做源数组，ary2叫做目标数组 
       现要求ary1中1-2下标的元素复制到ary2的0-1位置，如何实现？ 
1.  System.arrayCopy（） 
java中的数据类型： 
基本数据类型 
引用类型 - String  类可以作为引用类型 
String str = "a" 
Object类是所有类的父类 
如果某个变量的数据类型是Object类型，那么给此变量赋的值的类型可以是任意的引用类型 
数组是引用类型 
 
-arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 
src:源数组 
srcPos:源数组中开始复制的起始下标 
dest:目标数组 
destPos:目标数组中的起始下标（粘贴的起始位置） 
length:要复制的元素的个数 
 
练习： 
    创建2个数组，实现将源数组中从2-4位置的值复制到目标数组中3-5位置去 
String[] ary1 = {"a","c","c","e","t","y"};
String[] dest = new String[10];
System.out.println(Arrays.toString(dest));
//实现复制
System.arraycopy(ary1, 2, dest, 3, 3);
System.out.println(Arrays.toString(dest)); 
2.  Arrarys.copyOf()： 
数组的扩容 
数组一定初始化：数组的长度不可变 
public class ArrayCopyDemo02 {
public static void main(String[] args) {
int[] ary = {1,2,3,4,56,7};
//对数组进行扩容3个长度
ary = Arrays.copyOf(ary, ary.length+3);
System.out.println(Arrays.toString(ary));
}
} 
    类型[ ]  newArray  = Arrays.copyOf (类型[ ]  original , int  newLength ); 
       特点：生成的新数组是原始数组的副本 
       思考：newLength<原数组长度? 
System.arrayCopy(.....,int length） 
    思考： 
如果length值偏大，大到从源数组指定位置开始复制，结束位置下标>数组的最大下标.此时会报数组下标越界问题。 
 
数组复制两种方式的比较： 
1.  System.arraycopy(...) 
2.  Arrays.copyOf(..) 
 
方式一：复制更灵活 
方式二：数组的扩容 
 
练习： 
1.找出数组元素中的最大值并将找出的最大值放在数组最后一个元素的下一个位置。 
public static void main(String[] args) {
int[] ary = {12,4,4,5,6,776,86,5,86};
//找到最大值
int max = ary[0];
for(int i=1;iary[i]?max:ary[i];
}
//数组扩容
ary = Arrays.copyOf(ary, ary.length+1);
//最大值放到最后一个位置去
ary[ary.length-1] = max;
System.out.println(Arrays.toString(ary));
} 
2.3数组的排序 
所谓排序，是指将数组元素按照从小到大或从大到小的顺序重新排列； 
对于元素较多的数组，排序算法的优劣至关重要；一般情况下，通过排序过程中数组元素的交换次数来衡量排序算法的优劣； 
常用的排序算法有：冒泡排序、选择排序等。 
 
冒泡排序： 
    - 比较相邻的元素，如果违反最后的排序准则，则交换 
    - 比较时既可以采用"下沉"的方式（降序），也可以采用"上浮"的方式（升序） 
 
    案例： 
1.  用冒泡排序将数组中的最大值选出 
public class BubbleSort {
public static void main(String[] args) {
int[] ary = {12,34,54,67,1,2,4,24};
//选出最大值 - 冒泡排序
//i代表下标
for(int i=0;iary[i+1]){
//位置交换
int tmp = 0;
tmp = ary[i];
ary[i] = ary[i+1];
ary[i+1] = tmp;
}
}
System.out.println(Arrays.toString(ary));

}

} 
2.  对一个数组进行升序排列 
//控制冒泡的次数 8 7
for(int i=0;iary[j+1]){
int tmp = 0;
tmp = ary[j];
ary[j] = ary[j+1];
ary[j+1] = tmp;
}
}
}

System.out.println(Arrays.toString(ary)); 
选择排序： 
从0下标开始，依次和后面每个元素比较，小的往前放，第一次完毕，最小值出现在了最小下标处 
 
    案例： 
1.  用选择排序将数组中的最小值选出 
public class ChooseSort {
public static void main(String[] args) {
int[] ary = {12,34,54,67,1,2,4,24};
//i代表被比较数的下标
for(int i=1;iary[i]){
int tmp = 0;
tmp = ary[0];
ary[0] = ary[i];
ary[i] = tmp;
}
}
System.out.println(Arrays.toString(ary));
}

} 
2.  对一个数组进行升序排列 
//i用来表示对第几位求最小值,（下标）
for(int i=0;iary[j]){
int tmp = 0;
tmp = ary[i];
ary[i] = ary[j];
ary[j] = tmp;
}
}
}
System.out.println(Arrays.toString(ary));
} 
Arrays.sort(): 
int[] ary = {12,34,54,67,1,2,4,24};
//    Arrays.sort(ary);
//    System.out.println(Arrays.toString(ary));

String[] strs = {"jack","tom","amy","linda","rose"};
Arrays.sort(strs);
System.out.println(Arrays.toString(strs)); 
数组知识点： 
    数组的声明 
    数组的初始化 
    数组的访问 
-    数组的遍历 
数组的复制： 
    - System.arraycopy(.....) 
    - Arrays.copyOf(..) - 新数组 
数组的排序： 
    排序算法： 
-    冒泡排序 
-    简单选择排序 
-    Arrays.sort(数组) 
 
作业： 
1.数组长度为20，内容为0-9的任意数字，统计每个数字出现的次数。 
2.有一个长度为20数组，数组中的内容为0，1，实现一次排序，所有的0都排在1之前。（不用排序方法） 
3.创建一个长度为10的数组，数组内放置10个0-99之间的随机整数作为数组元素。要求查询出数组中的最小值，并打印显示在界面上。然后，将数组的长度扩容为11，将查询到的最小值记录为数组的第一个元素，并打印扩容后的数组的内容 
 
3.方法 
各种语言都有方法的概念（有的语言称其为函数或过程） 
       方法用于封装一段特定的逻辑功能 
       方法可以在程序中反复被调用； 
       方法可减少代码重复，便于程序的维护。 
 
方法的定义：5部分 
       方法是类的成员之一。 
       修饰符，返回值类型，方法名，参数列表，方法体 
public class MethodDemo01 {
public static void main(String[] args) {
int i=19,x=20;
int max = getMaxValue(i,x);
System.out.println("最大是值："+max);
}


public static int getMaxValue(int a,int b){
return a>b?a:b;
}  
1、public:访问控制修饰符 
2、返回值类型： 
     1.可以是基本数据类型，也可以是引用类型 
     2.一个方法可以有返回值，也可以没有返回值 
3、方法名： 
    1.见名知意 - 体现出出方法的功能 
    2.驼峰命名法 
4、方法体：方法功能的具体实现 
 
5、参数列表：方法名（参数列表） 
5.1.参数列表的使用： 
参数列表：可以方法1个参数，也可以放多个，还可以不放 
    参数：变量    数据类型   参数名称 
 
注意点： 
1.  如果某个方法的参数列表有参数，那么调用这个方法时一定要传递类型匹配，数量匹配的值过去。 
2.  方法的调用问题： 
a)   如果是同一个类中的非static方法调用目标方法（非static），可以直接写方法名调用 
b)   如果是不同类中的方法调用目标方法（非static），先创建类的对象，通过对象调用 
c)   如果是static方法调用目标方法（非static），可以将目标方法定义为static 
      
练习： 
用户输入两个数字，对两个数字求和 
用户输入两个数字，求出最大值 
求两个数的最大值 
public static void main(String[] args) {
int i=19,x=20;
int max = getMaxValue(i,x);
System.out.println("最大是值："+max);
}
public static int getMaxValue(int a,int b){
return a>b?a:b;
} 
求两个值的和 
public class SumDemo {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入两个整数，用空格隔开：");
int a = sc.nextInt();
int b = sc.nextInt();
//求二者的和
int sum = getSum(a,b);
System.out.println("和是："+sum);
sc.close();
}

public static int getSum(int a,int b){
return a+b;
}

} 
5.2形参，实参 
5.3局部变量的声明周期  
5.4可变参数： 
           语法： 
注意点： 
 
1.如果参数列表有多个参数,那么可变参数一定是位于参数列表的最后,参数列表中最多只能有一个可变参数 
2.底层采用的数组 
3.如果方法的参数是可变参数,那么传递的实参可以是一个数组  
       可变参数的访问 
 
4.猜字母游戏 
其游戏规则为：程序随机产生5个按照一定顺序排列的字符作为猜测的结果，由玩家来猜测此字符串。玩家可以猜测多次，每猜测一次，则由系统提示结果。如果猜测的完全正确，则游戏结束，计算玩家的游戏得分并输出（每次字符100分，猜错一次扣10分）；如果没有猜对，则提示猜测的结果，如猜对了几个字符，以及猜对了几个字符的位置等信息，并提示玩家游戏继续。 
 
5.作业 
为猜字母游戏添加等级。等级设为三个等级：5，7，9，代表所需要猜测的字母个数。游戏开始时，由玩家选择游戏等级（5，7，9）.如果选择7，则会随机产生7个字符，然后玩家输入一个字符串包含7个字符，看这7个字符和随机产生的7个字符比较，是否正确，并统计分数。另外，如果输入其他，重新提示输入游戏等级。 

Day06 
1.内容回顾 
1.  数组 
数组的声明 
数组的初始化 
数组的访问 
-    数组的遍历 
数组的复制： 
    -System.arraycopy(Object src,int srcPos,Object dest,int destPos,int length) - void 
    -Arrays.copyOf(Object original,int newLength); - T[] 
数组的排序： 
    冒泡排序：bubble 
        相邻元素两两相比，大的/小的往后放 
    简单选择排序： 
从第一个元素开始，拿此位置的元素和它之后的所有元素依次比较，小的/大的前放。 
Arrays.sort(T[]) 
 
2.方法 
1.  方法出现的目的（原因） 
2.  定义： 
修饰符  返回值类型 方法名（参数列表）{ 
 方法体 
} 
参数列表： 
 
1.  位置可以放1个，多个参数，也可以不放参数 
      a)   参数：数据类型  参数名称 
方法的调用： 
自定义一个非static方法，调用这个方法的方式： 
1.  同一类中的其他非static方法调用，写方法名 
2.  同一个类中的static方法调用，将非static方法变为static 
3.  在另外的一个类中调用此方法，要先创建类的对象，通过对象来调用 
 
3.方法 
1参数列表：方法名（参数列表） 
1.1参数的分类： 
    形参：在定义方法时参数列表中定义的参数 
    实参：在调用方法时传递的具体的值/变量 
1.2局部变量的生命周期 
    变量分类： 
       按照变量声明的位置分类： 
              成员变量：声明在类的内部，方法的外部，作用于整个类的范围之内 
              局部变量:声明在方法的内部，作用范围是紧邻它的一对{} 
              参数列表中的参数是局部变量，作用在本方法内部 
 
5.4可变参数：个数可变 
           语法: 
                数据类型...参数名称； 
                int...is; 
注意点： 
1.如果参数列表有多个参数,那么可变参数一定是位于参数列表的最后,参数列表中最多只能有一个可变参数 
2.底层采用的数组 
3.如果方法的参数是可变参数,那么传递的实参可以是一个数组 
       可变参数的访问：和数组的访问方式相同 
public static void demo(int...a){

//    //将a中接受的所有数字输出
//    for(int i=0;i 
方法的定义： 
修饰符 
返回值类型： 
方法名 
方法体 
参数列表： 
    参数的分类 
    参数列表的参数其实是局部变量 
    可变参数：数据类型...参数名 
4.猜字母游戏 
其游戏规则为：程序随机产生5个按照一定顺序排列的字符作为猜测的结果，由玩家来猜测此字符串。玩家可以猜测多次，每猜测一次，则由系统提示结果。如果猜测的完全正确，则游戏结束，计算玩家的游戏得分并输出（每次字符100分，猜错一次扣10分）；如果没有猜对，则提示猜测的结果，如猜对了几个字符，以及猜对了几个字符的位置等信息，并提示玩家游戏继续。 
思路： 
1.  先随机生成5个字符（A-Z） - generate() 
2.  用户输入 
3.  比较   - check() 
     a)   目标：char[5] 
     b)   用户输入的String.toUpperCase()-->char[] 
                          toCharArray() 
     c)   两个char[]进行比较 
generate()随机生成5个字符 
//随机生成5个字符
public static char[] generate() {
char[] letters = {'A','B','C','D','E','F','G',
'H','I','J','K','L','M','N','O','P',
'Q','R','S','T','U','V','W','X','Y','Z'};
boolean[] flags = new boolean[26];

char[] chs = new char[5];
//生成5个字符
for(int i=0;i<5;i++){
int index;
do{
index = (int)(Math.random()*26);
}while(flags[index]);
chs[i] = letters[index];
flags[index] = true;
}
return chs;
} 
check(char[] ch1,char[] ch2) 
public static int[] check(char[] inputArray,
char[] destArray) {

int[] result = new int[2];
//取到inputArray中的每个元素
for(int i=0;i 
main() 
public static void main(String[] args) {
System.out.println("欢迎进入猜字母游戏：");
//程序自动生成5个字符 - char[]
char[] destArray = generate();
System.out.println("请输入猜测的字符串：");
Scanner sc = new Scanner(System.in);

//定义一个计数器统计答错的次数
int count=0;
while(true){
String input = sc.next().toUpperCase();
if("EXIT".equals(input)){
//退出程序
break;
}
//String转换为char[]
char[] inputArray = input.toCharArray();
if(inputArray.length!=5){
System.out.println("输入的字符个数有误，请重新输入！");
count++;
continue;
}

int[] result = check(inputArray,destArray);
System.out.println(Arrays.toString(result));
//根据check方法的返回值给出用户提示
if(result[1]==destArray.length){
int score = 100*destArray.length-10*count;
System.out.println("恭喜你，答对了！得分是："+score);
break;
}else{
count++;
System.out.println("答对的字符个数是："+result[0]+""
+ ",其中位置正确的字符个数是："+result[1]);
System.out.println("请重新输入猜测的字符串：");
}
}
sc.close();
} 
5.作业 
为猜字母游戏添加等级。等级设为三个等级：5，7，9，代表所需要猜测的字母个数。游戏开始时，由玩家选择游戏等级（5，7，9）.如果选择7，则会随机产生7个字符，然后玩家输入一个字符串包含7个字符，看这7个字符和随机产生的7个字符比较，是否正确，并统计分数。另外，如果输入其他，重新提示输入游戏等级。 
 
JAVA语言基础知识点梳理： 
1.  java的运行机制以及环境的搭建 
 
2.  变量：变量名的命名规范 
3.  java的基本数据类型：8种 
    a)   类型间的运算 
    b)   类型间的转换 
4.  运算符和表达式 
    a)   算术，关系，逻辑，字符串连接，赋值，三目 
5.  分支结构： 
    a)   if..else 
    b)   switch..case 
6.  循环结构： 
     a)   while 
     b)   do..while 
     c)   for 
        d)   break,continue 
        e)   循环嵌套 
7.  数组： 
    a)   数组的声明，初始化，访问（遍历） 
    b)   数组的复制 
        c)   数组的排序：冒泡，简单选择 
                                Arrays.sort(T[]) 
8.  方法: 
     a)   定义：5部分 
修饰符  返回值类型  方法名（参数列表）{} 
参数列表： 
   参数的分类：形参，实参 
   参数列表中的参数其实是局部变量 
u  局部变量的生命周期 
可变参数：数据类型...参数名 
    注意点： 
1.  底层采用的是数组 
2.  因为第一点，所有访问可变参数的方式和数组一样，在调用一个参数列表中有可变参数的方法时，可以传递一个数组过 
3.  可变参数如果出现在参数列表，一定是位于最后，参数列表中最多只能有一个可变参数 

 
 

作者：Darren 
QQ：603026148 
以上内容归Darren所有，如果有什么错误或者不足的地方请联系我，希望我们共同进步。 
  
					
										


					
						欢迎分享，转载请注明来源：内存溢出
原文地址: http://outofmemory.cn/zaji/5713312.html

py-03-JAVASE

发表评论

评论列表（0条）