本帖最后由 小石姐姐 于 2017-12-7 14:44 编辑
day03笔记
顺序结构
if 语句1
if （关系表达式）｛
语句体
｝
执行流程：首先看表达式的值是否正确
正确就执行语句，错误不执行语句。
int a =10
int b =20
if (a==b){
system.out.println("a等于b")
}
system.out.println ("结束")；
第二种
if (关系表达式){
system.out.print ("语句体1")
}else {
system.out.print ("语句体2")
}
第三种
if (关系表达式1)｛
system.out.println ("语句体1");
｝else if (关系表达式2) {
system.out .println ("语句体2");
}else if (关系表达式3){
system.out.println ("语句体3");
}else {
system.out.println ("数据体4");
}
注意:else 后面不再加关系表达式。
注意：当两个数a b比较大小时我不想直接输出结果时，我要定义一个变量用于接受较大的值。
int max;
if (a>b){
max =a
}else {
max =b
}
输出较大值
system.out.println ("较大值"+max);
switch
注意：表达式:byte,short,int,char
JDK5以后可以是枚举
JDK7以后可以是字符串
case:就是要和表达式进行比较的值
break:表示中断,结束的意思。
default:表示所有的情况都不匹配的时候，就执行语句体n+1。和if语句的else相似。
执行流程：
switch语句格式：
switch(表达式) {
case 值1:
语句体1;
break;
case 值2:
语句体2;
break;
...
default:
语句体n+1;
break;
switch 语句的穿透
switch (month){
case 3:
case 4:
case 5:
System.out.println("春天");
break;
case 6:
case 7:
case 8:
System.out.println("夏天");
break;
case 9:
case 10:
case 11:
System.out.println("秋天");
break;
case 12:
case 1:
case 2:
System.out.println("冬天");
break;
default:
语句体n+1;
break;
for 语句
for (初始化语句;判断条件语句；控制条件语句){
循环体语句;
}
system.out.println();
for 循环语句求和；
先定义一个求和变量sum
初始化值为零
举例：
public class ForTest2 {
public static void main(String[] args) {
//定义求和变量，初始化值是0
int sum = 0;
//获取1-5之间的数据，用for循环实现
for(int x=1; x<=5; x++) {
//把每一次获取到的数据，累加起来就可以了
//sum = sum + x;
/*
* 第一次：sum = 0 + 1 = 1
* 第二次：sum = 1 + 2 = 3
* 第三次：sum = 3 + 3 = 6
* 第四次：sum = 6 + 4 = 10
* 第五次：sum = 10 + 5 = 15
*/
sum += x;
}
//输出求和结果
System.out.println("sum:"+sum);
要求打印水仙花数案例
public class ForTest5 {
public static void main(String[] args) {
//定义统计变量，初始化值是0
int count = 0;
//获取三位数，用for循环实现
for(int x=100; x<1000; x++) {
//获取三位数的个位，十位，百位
int ge = x%10;
int shi = x/10%10;
int bai = x/10/10%10;
//判断这个三位数是否是水仙花数，如果是，统计变量++
if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == x) {
count++;
}
}
//输出统计结果就可以了
System.out.println("水仙花数共有："+count+"个");
}
}
while 循环语句
基本格式
while(判断条件语句) {
循环体语句;
}
扩展格式
初始化语句;
while(判断条件语句) {
循环体语句;
控制条件语句;
}
do while 循环语句
基本格式
do {
循环体语句;
}while((判断条件语句);
扩展格式
初始化语句;
do {
循环体语句;
控制条件语句;
} while((判断条件语句);
三种循环语句的区别
A:do...while至少执行一次循环体
B:for,while循环先判断条件是否成立，然后决定是否执行循环体
循环的使用推荐：
for -- while -- do...while
控制循环语句
break 和 continue
break 退出当前循环
continue 退出本次循环
day04笔记
1、随机数的产生
三步骤
A:导包
import java.util.Random;
B:创建对象
Random r = new Random();
C:获取随机数
int number = r.nextInt(10);
10 的意思是产生0-9的随机数，不包括9；
案例：
public class RandomTest {
public static void main(String[] args) {
// 系统产生一个随机数1-100之间的。
Random r = new Random();
int number = r.nextInt(100) + 1;
while(true){
// 键盘录入我们要猜的数据
Scanner sc = new Scanner(System.in);
System.out.println("请输入你要猜的数字(1-100)：");
int guessNumber = sc.nextInt();
// 比较这两个数据(用if语句)
if (guessNumber > number) {
System.out.println("你猜的数据" + guessNumber + "大了");
} else if (guessNumber < number) {
System.out.println("你猜的数据" + guessNumber + "小了");
} else {
System.out.println("恭喜你,猜中了");
break;
}
}
}
}
2、数组
A:定义格式
数据类型[] 数组名;
数组的初始化方式分为动态初始化和静态初始化
动态初始化
格式：数据类型[] 数组名 = new 数据类型[数组长度];
案例： int[] arr = new int[3];
解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值。3表示数组的长度；其实就是数组中的元素个数。
静态初始化
格式：数据类型[] 数组名 = {元素1,元素2,...};
案例：int[] arr = {1,2,3};
其实数组中的每个元素都是有编号的，编号是从0开始的，最大的编号就是数组的长度。
数组名[编号] -- 数组名[索引]
B:使用数组是常出现的两个小问题
1:java.lang.ArrayIndexOutOfBoundsException
数组越界异常
产生的原因：就是你访问了不存在的索引元素。
2、:java.lang.NullPointerException
空指针异常
产生的原因：数组已经不指向堆内存的数据了，你还使用数组名去访问元素。
C:数组的赋值
给数组中的元素赋值
arr[0] = 100;
arr[2] = 200;
D:数组的遍历
数组遍历(依次输出数组中的每一个元素)
获取数组中元素的个数：数组名.length
for(int x=0; x<arr.length; x++) {
System.out.println(arr[x]);
}
E:数组获取最值
首先要先定义一个参照物
int max =arr[0];
案例：
public class ArrayTest2 {
public static void main(String[] args) {
//定义数组
int[] arr = {12,98,45,73,60};
//定义参照物
int max = arr[0];
//遍历数组，获取除了0以外的所有元素，进行比较
for(int x=1; x<arr.length; x++) {
if(arr[x] > max) {
max = arr[x];
}
}
System.out.println("数组中的最大值是："+max);
}
}
F:二维数组
格式：数据类型[][] 数组名;
案例：
数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
遍历二维数组
int [][]arr={{11,22,34,},{33,17}};
for (int a=0;a<arr.length;a++){
for (int b=0;b<arr[a].length;b++){
System.out.print(arr[a]+ " ");
}
}
数组题一般分为三步骤
数组的三步骤
1、定义一个数组
int []arr = new int [3]或 int []arr={1,2,3,}
2、为数组赋值
单（几个）个定值
arr[0]=100; 多个数据时，没有思路的话，
arr[1]=200; 可以多写几次，然后再用循环语句表示；
多个定值
for (int a=0;a<arr.length;a++){
arr[a]=a;}
3、遍历数组（输出）
单个（几个）
system.out.println(arr[0])
system.out.println(arr[1])
多个
for (int a =0 ;a<arr.length;a++){ 一维数组输出
System.out.println(arr[a]);}
day05笔记
1、方法就是完成特定功能的代码块
方法定义的格式
修饰符 返回值类型 方法名(参数类型 参数名1，参数类型 参数名2…) {
函数体;
return 返回值;
}
注意事项：
写一个方法首先有两点需要明确
返回值类型 明确功能结果的数据类型
参数列表 明确有几个参数，以及参数的类型
按照格式和两个明确来完成如下功能
2、求和方法的调用
案例：
public class test01 {
public static void main(String[] args) {
sum (10,20);
单独调用 没有意义
//System.out.println(sum(10,20));
输出调用 不能进行操作
int result =sum (10,20);
//赋值调用
result +=10;
System.out.println("result:"+result);
}
使用汉字写出定义方法的格式
定义一个方法: 求两个整数的和
要求: 1.注释中描述该方法的作用
2.注释中明确该方法的返回值类型
3.注释中明确该方法的参数的个数和类型
两个注意：返回值的类型
参数列表
public static int sum (int a ,int b){
int c= a+b;
return c;
}
}
3、 方法中获取最值
案例：public class test05 {
public static void main(String[] args) {
Scanner sc =new Scanner(System.in);
System.out.println("输入第一个数字");
int a = sc.nextInt();
System.out.println("输入第二个数字");
int b = sc.nextInt();
System.out.println("输入第三个数字");
int c = sc.nextInt();
//输出调用
int Max=guessMax(a,b,c);
System.out.println("Max:"+Max);
}
两个明确：
返回值类型：int
参数列表：int a ,int b ,int c ;
public static int guessMax(int a ,int b ,int c){
if(a>b){
if(a>c){
return a ;
}else return c;
}else {
if(b>c){
return b;
}else {
return c;
}
}
}
}
4、比较两个数是否相等
案例：
public class test02 {
public static void main(String[] args) {
Scanner sc =new Scanner(System.in);
System.out.println("请输入一个数字");
int a =sc.nextInt();
System.out.println("请输入二个数字");
int b =sc.nextInt();
boolean x =compare(a,b);
System.out.println(compare(a,b));
}
两个注意：
返回值类型 boolean
参数列表 int a ,int b ;
public static boolean compare(int a, int b ){
if (a>b){
return true;
}else {
return false;
}
}
}
5、void修饰的方法的调用
没有明确返回值的函数调用：
其实就是void类型方法的调用
只能单独调用
使用方法获取1-n的值
public class test06 {
public static void main(String[] args) {
//方法调用
printNumber(10);
}
/*定义一个方法传递一个整数（该整数大于1），在控制台打印1到该数据的值
* 两个注意：
* 返回值类型 void
* 参数列表 int n
public static void printNumber(int n){
for (int x=1;x<n;x++){
System.out.println(x);
}
}
}
6、打印水仙花数
public class test08 {
public static void main(String[] args) {
//调用方法
printFlower();
}
public static void printFlower(){
for (int x =100;x<10000;x++){
int ge =x%10;
int shi =x/10%10;
int bai=x/100%10;
int qian=x/1000%10;
if ((ge*ge*ge+shi*shi*shi+bai*bai*bai+qian*qian*qian)==x){
System.out.println(x);
}
}
}
}
7、方法重载
在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
方法重载特点
与返回值类型无关，只看方法名和参数列表
在调用时，虚拟机通过参数列表的不同来区分同名方法
案例：
public class test12 {
public static void main(String[] args) {
//方法调用
System.out.println(compare (1,10));
System.out.println(compare( 1.0, 10.0));
}
public static boolean compare(int a ,int b){
return a==b;
}
public static boolean compare(double a ,double b){
return a==b;
}
8、方法中参数的传递
A 方法的参数是基本类型的时候：
形式参数的改变不影响实际参数。
形式参数：用于接收实际数据的变量
实际参数：实际参与运算的变量
B 方法的参数是引用类型：
形式参数的改变直接影响实际参数
案例
public class ArgsDemo2 {
public static void main(String[] args) {
// 定义数组
int[] arr = { 1, 2, 3, 4, 5 };
// 遍历数组
for (int x = 0; x < arr.length; x++) {
System.out.println(arr[x]);
}
System.out.println("----------------");
change(arr);
for (int x = 0; x < arr.length; x++) {
System.out.println(arr[x]);
}
}
public static void change(int[] arr) {
for (int x = 0; x < arr.length; x++) {
// 如果元素是偶数，值就变为以前的2倍
if (arr[x] % 2 == 0) {
arr[x] *= 2;
}
}
}
}
9、把遍历数组改进为方法实现，并调用方法
public class MethodTest {
public static void main(String[] args) {
// 定义数组
int[] arr = { 11, 22, 33, 44, 55 };
// 遍历
// for (int x = 0; x < arr.length; x++) {
// System.out.println(arr[x]);
// }
//用方法改进
//printArray(arr);
//这一次虽然可以，但是我觉得格式不好看，能不能打印成下面的格式呢?
//[元素1, 元素2, 元素3, ...]
printArray(arr);
}
public static void printArray(int[] arr) {
System.out.print("[");
for(int x=0; x<arr.length; x++){
if(x==arr.length-1){
System.out.println(arr[x]+"]");
}else {
System.out.print(arr[x]+", ");
}
}
}
/*
两个明确：
返回值类型：void
参数列表：int[] arr
// public static void printArray(int[] arr) {
// for(int x=0; x<arr.length; x++){
// System.out.println(arr[x]);
// }
// }
10、遍历数组使用方法获取最值
案例：
public class test17 {
public static void main(String[] args) {
int []arr={1,2,3,4,5};
int max = getMax(arr);
System.out.println("max:"+max);
}
public static int getMax(int[]arr){
int max =arr[0];
for (int x =0;x<arr.length;x++){
if(max<arr[x]){
max=arr[x];
}
}return max;
}
}
11、遍历数组求元素的和用方法实现
案例：
public class test18 {
public static void main(String[] args) {
int[]arr={1,2,3,4,};
int sum =sum (arr);
System.out.println("sum:"+sum);
}
public static int sum (int arr[]){
int sum =0;
for (int x=0;x<arr.length;x++){
sum+=arr[x];
}return sum ;
}
}
day06笔记
1、Eclipse断点调试
Eclipse的断点调试可以查看程序的执行流程和解决程序中的bug
A:什么是断点：
就是一个标记，从哪里开始。
B:如何设置断点：
你想看哪里的程序，你就在那个有效程序的左边双击即可。
C:在哪里设置断点：
哪里不会点哪里。
目前：我们就在每个方法的第一条有效语句上都加。
D:如何运行设置断点后的程序：
右键 -- Debug as -- Java Application
E:看哪些地方：
Debug：断点测试的地方
在这个地方，记住F6，或者点击也可以。一次看一行的执行过程。
Variables：查看程序的变量变化
ForDemo：被查看的源文件
Console：控制台
F:如何去断点：
再次双击即可
找到Debug视图，Variables界面，找到Breakpoints，并点击，然后看到所有的断点，最后点击那个双叉。
|
|
收藏
淘帖
踩
