Java语言编程结构（续）

###04.01_Java语言基础(控制跳转语句break语句)

* A:break的使用场景

* 只能在switch和循环(while,for,do_while())中 

案例：

class Demo1_Break {
public static void main(String[] args) {
                //break；写在这报错，break只能用在循环和switch语句中
for (int x = 1;x <= 10 ;x++ ) {
if (x == 4) {
break;//跳出循环
}
 
System.out.println("x 
class Demo4_Return {
public static void main(String[] args) {
for (int i = 1;i <= 10 ;i++ ) {
if (i == 4) {
//break;//停止循环
return;//返回的意思,用来返回方法
}
}
 
System.out.println("循环结束了");
}
}
= " + x);
}
}
}

###04.02_Java语言基础(控制跳转语句continue语句)

* A:continue的使用场景

* 只能在循环中 ,提前结束本次循环(循环体中continue后面的语句将不再执行),继续进行下一次

/*

* A:continue的使用场景

* 只能在循环中 

*/

案例：

class Demo2_Continue {
public static void main(String[] args) {
for (int x = 1;x <= 10 ;x++ ) {
if (x == 4) {
continue;//终止本次循环,继续下次循环
}
 
System.out.println("x = " + x);
}
}
}

###04.03_Java语言基础(控制跳转语句标号)

* 标号:标记某个循环对其控制

* 标号组成规则:其实就是合法的标识符

案例：

class Demo3_Mark {//mark 标记
public static void main(String[] args) {
/*outer: for (int i = 1;i <= 10 ;i++ ) {//a就是标号,只要是合法的标识符即可
System.out.println("i = " + i);
inner: for (int j = 1;j <= 10 ;j++ ) {
System.out.println("j = " + j);
break outer;
}
}*/
 
System.out.println("大家好");
http://www.heima.com         //这里http:就是一个标号，而后面的//是java中的注释，所以相当于给输出语句做了一个标记，没有什么实际的意义
System.out.println("才是真的好");
}
}

###04.04_Java语言基础(控制调整语句练习)

* A:练习题

* 

for(int x=1; x<=10; x++) {

if(x%3==0) {

//在此处填写代码

}

System.out.println(“Java基础班”);

}

我想在控制台输出2次:“Java基础班“

我想在控制台输出7次:“Java基础班“

我想在控制台输出13次:“Java基础班“

案例：

class Test1 {
public static void main(String[] args) {
for(int x=1; x<=10; x++) {
if(x%3==0) {
//break;//我想在控制台输出2次:“Java基础班“
//continue;//我想在控制台输出7次:“Java基础班“
System.out.println("Java基础班");//我想在控制台输出13次:“Java基础班“
}
System.out.println("Java基础班");
}
}
}

###04.05_Java语言基础(控制跳转语句return语句)

* A:return的作用

* 返回

* 其实它的作用不是结束循环的，而是结束方法的。

* B:案例演示

* return和break以及continue的区别?

* return是结束方法

* break是跳出循环

* continue是终止本次循环继续下次循环

案例：

###04.06_Java语言基础(方法概述和格式说明)

* A:为什么要有方法

* 提高代码的复用性   //

* B:什么是方法

* 完成特定功能的代码块。 

* C:方法的格式

* 

修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) {

方法体语句;

return 返回值; 

} 

* D:方法的格式说明

* 修饰符：目前就用 public static。后面我们再详细的讲解其他的修饰符。

* 返回值类型：就是功能结果的数据类型。

* 方法名：符合命名规则即可。方便我们的调用。

* 参数：

* 实际参数：就是实际参与运算的。

* 形式参数；就是方法定义上的，用于接收实际参数的。

* 参数类型：就是参数的数据类型

* 参数名：就是变量名

* 方法体语句：就是完成功能的代码。

* return：结束方法的。

* 返回值：就是功能的结果，由return带给调用者。 

###04.07_Java语言基础(方法之求和案例及其调用)

* A:如何写一个方法

* 1,明确返回值类型

* 2,明确参数列表 

* B:案例演示

* 需求：求两个数据之和的案例

* C:方法调用图解

案例：

class Demo2_Sum {
public static void main(String[] args) {
/*int a = 10;
int b = 20;
int sum = a + b;
System.out.println(sum);
 
int c = 30;
int d = 40;
int sum2 = c + d;
System.out.println(sum2);*/
 
int sum = add(10,20);
System.out.println(sum);
 
//add(30,40);//有返回值方法的单独调用,没有意义
System.out.println(add(30,40));//这样调用是可以,but如果需要用这个结果不推荐这样调用
 
//盘子 = 炒菜(地沟油,苏丹红,镉大米,烂白菜);
}
public static int add(int a,int b) {//int a = 10,int b = 20
int sum = a + b;
return sum;//如果有返回值必须用return语句带回
}
 
/*
盘子 炒菜(油,调料,米,菜) {
炒菜的动作
return 一盘菜;
}
*/
 
}

###04.08_Java语言基础(方法的注意事项)

* A:方法调用(有具体返回值)

* a:单独调用,一般来说没有意义，所以不推荐。

* b:输出调用,但是不够好。因为我们可能需要针对结果进行进一步的操作。

* c:赋值调用,推荐方案。

* B:案例演示

* a:方法不调用不执行

* b:方法与方法是平级关系，不能嵌套定义

* c:方法定义的时候参数之间用逗号隔开

* d:方法调用的时候不用在传递数据类型

* e:如果方法有明确的返回值，一定要有return带回一个值

###04.09_Java语言基础(方法的练习)

* A:案例演示

* 需求：键盘录入两个数据，返回两个数中的较大值

* B:案例演示

* 需求：键盘录入两个数据，比较两个数是否相等 

案例：

import java.util.Scanner;
class Test1_Method {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);//创建键盘录入对象
System.out.println("请输入第一个整数:");
int x = sc.nextInt();//将键盘录入的整数存储在x中
System.out.println("请输入第二个整数:");
int y = sc.nextInt();//将键盘录入的整数存储在y中
 
//int max = getMax(x,y);
//System.out.println(max);
 
boolean b = isEquals(x,y);
System.out.println(b);
}
 
/*
返回连个整数的较大值
1,明确返回值类型 int
2,明确参数列表 int a,int b
*/
public static int getMax(int a,int b) {
return a > b ? a : b;
}
 
/*
判断两个整数是否相等
1,明确返回值类型 boolean
2,明确参数列表 int a,int b
*/
public static boolean isEquals(int a,int b) {//isEquals 是否相等
return a == b;
}
}

    

###04.10_Java语言基础(方法之输出星形及其调用)

* A:案例演示

* 需求：根据键盘录入的行数和列数，在控制台输出星形

* B:方法调用：(无返回值,void)

* 单独调用

* 输出调用(错误)

* 赋值调用(错误)

案例：

import java.util.Scanner;
class Demo3_Method {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);//创建键盘录入对象
System.out.println("请输入行数:");
int row = sc.nextInt();//将键盘录入的行数存储在row中
System.out.println("请输入列数:");
int column = sc.nextInt();//将键盘录入的列数存储在column中
//System.out.println(print(row,column));//错误: 此处不允许使用 '空' 类型,返回值是void的方法不能输出调用
//返回值是void的方法只能单独调用
print(row,column);
}
 
/*
在控制台输出矩形星形
1,明确返回值类型,经分析没有具体的返回值类型,void
2,明确参数列表int a,int b
*/
 
public static void print(int a,int b) {
for (int i = 1;i <= a ;i++ ) {//行数
for (int j = 1;j <= b ;j++ ) {//列数
System.out.print("*");
}
System.out.println();
}
 
//return ;//如果返回值类型是void,return可以省略,即使省略系统也会默认给加上,形式是return;
}
}

###04.11_Java语言基础(方法的练习)

* A:案例演示

* 需求：根据键盘录入的数据输出对应的乘法表

案例：

import java.util.Scanner;
class Test2_Method {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);//创建键盘录入对象
System.out.println("请录入一个整数,范围在1-9之间");
int num = sc.nextInt();//将键盘录入的整数存储在num中
print99(num);
}
 
/*
打印99乘法表
1,返回值类型void
2,参数列表,int a
*/
 
public static void print99(int a) {
for (int i = 1;i <= a ;i++ ) {//行数
for (int j = 1;j <= i ;j++ ) {//列数
System.out.print(j + "*" + i + "=" + (i * j) + "\t" );
}
System.out.println();
}
}
}

###04.12_Java语言基础(方法重载概述和基本使用)

* A:方法重载概述

* 求和案例

* 2个整数

* 3个整数

* 4个整数

* B:方法重载：

* 在同一个类中，方法名相同，参数列表不同。与返回值类型无关。

* 参数列表不同：

* A:参数个数不同

* B:参数类型不同

* C:参数的顺序不同(算重载,但是在开发中不用)

案例：

class Demo4_Overload {//overload重载
public static void main(String[] args) {
double sum1 = add(10,20.1);
System.out.println(sum1);
 
int sum2 = add(10,20,30);
System.out.println(sum2);
 
double sum3 = add(12.3,13);
System.out.println(sum3);
}
 
/*
求两个整数的和
1,返回值类型int
2,参数列表 int a,int b
*/
 
public static double add(int a,double b) {
return a + b;
}
 
/*
求三个整数的和
1,返回值类型int
2,参数列表 int a,int b,int c
*/
 
public static int add(int a,int b,int c) {
return a + b + c;
}
 
/*
求两个小数的和
1,返回值类型double
2,参数列表 double a,double b
*/
 
public static double add(double a,int b) {
return a + b;
}
}

###04.13_Java语言基础(方法重载练习比较数据是否相等)

* A:案例演示

* 需求：比较两个数据是否相等。

* 参数类型分别为两个int类型，两个double类型，并在main方法中进行测试

案例：

class Test3_Overload {
public static void main(String[] args) {
boolean b1 = isEquals(10,10);
System.out.println(b1);
 
boolean b2 = isEquals(10.5,10.5);
System.out.println(b2);
}
 
/*
比较两个数据是否相等
1,返回值类型boolean
2,参数列表int a,int b
*/
 
public static boolean isEquals(int a,int b) {
return a == b;
}
 
/*
比较两个数据是否相等
1,返回值类型boolean
2,参数列表double a,double b
*/
 
public static boolean isEquals(double a,double b) {
return a == b;
}
}

###04.14_Java语言基础(数组概述和定义格式说明)(了解)

* A:为什么要有数组(容器)

* 为了存储同种数据类型的多个值

* B:数组概念

* 数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。

* 数组既可以存储基本数据类型，也可以存储引用数据类型。

* C:数组定义格式

数据类型[] 数组名 = new 数据类型[数组的长度];

案例：

class Demo1_Array {
public static void main(String[] args) {
int x = 10;
x = 20;
System.out.println("x = " + x);
//数据类型[] 数组名 = new 数据类型[数组的长度];
int[] arr = new int[5];//可以存储五个int类型的数据
/*
左边:
int:数据类型
[]:代表的数组,几个中括号就代表几维数组
arr:合法的标识符
右边:
new:创建新的实体或对象
int:数据类型
[]:代表的数组
5:代表数组的长度
*/
 
}
}

###04.15_Java语言基础(数组的初始化动态初始化)(掌握)

* A:什么是数组的初始化

* 就是为数组开辟连续的内存空间，并为每个数组元素赋予值 

* B:如何对数组进行初始化

* a:动态初始化 只指定长度，由系统给出初始化值

* int[] arr = new int[5]; 

* b:静态初始化 给出初始化值，由系统决定长度

* C:动态初始化的格式：

* 数据类型[] 数组名 = new 数据类型[数组长度];

* D:案例演示

* 输出数组名称和数组元素

/*

        整数类型:byte,short,int,long默认初始化值都是0

浮点类型:float,double默认初始化值都是0.0

布尔类型:boolean默认初始化值false

字符类型:char默认初始化值'\u0000'  之前讲过''，只能放一个字符，但是'\'代表转义字符，u代表unicode编码，java采用的是unicode编码，\u相当于把

后面的4个0给转义了。

char在内存中占的两个字节,是16个二进制位

\u0000,每一个0其实代表的是16进制的0,那么四个0就是代表16个二进制位

[I@19bb25a

[代表是数组,几个就代表几维

I代表是int类型

@是固定的

19bb25a代表的是数组的地址值

*/

class Demo2_Array {
public static void main(String[] args) {
//数据类型[] 数组名 = new 数据类型[数组长度];
int[] arr = new int[5];//动态初始化,在内存中开辟连续的5块空间
 
System.out.println(arr[0]);//系统给出默认初始化值,整数类型的都是0
arr[0] = 10;
 
System.out.println(arr[0]);
 
System.out.println(arr);//[I@19bb25a
}
}

###04.16_Java语言基础(Java中的内存分配以及栈和堆的区别)

* A:栈(掌握)

* 存储局部变量 

* B:堆(掌握)

* 存储new出来的数组或对象 

* C:方法区

* 面向对象部分讲解 

* D:本地方法区  （native）

* 和系统相关 

* E:寄存器

* 给CPU使用

当编译时会生成class文件，这些class文件会保存在硬盘上，当运行时，class文件被加载到内存中，内存中要进行代码的执行，此时有进栈的也有进堆的，谁进栈，谁进堆，要看它属于哪一块，如果是局部变量就进栈，new出来的东西就进堆。一定要跑到内存中才能执行，如果在电脑中开了过多的应用程序，电脑就会卡。

案例：

class Demo3_Array {
public static void main(String[] args) {
int[] arr = new int[3];
}

###04.17_Java语言基础(数组的内存图解1一个数组)(掌握)

* A:画图演示

* 一个数组

案例：

class Demo3_Array {
public static void main(String[] args) {
int[] arr = new int[3];//动态初始化,创建3块连续的空间
System.out.println(arr);
arr[0] = 10;
arr[1] = 20;
 
System.out.println(arr[0]);
System.out.println(arr[1]);
}
}

###04.18_Java语言基础(数组的内存图解2二个数组)(了解)

* A:画图演示

* 二个不同的数组

案例：

class Demo4_Array {
public static void main(String[] args) {
int[] arr1 = new int[3];//创建数组,长度为3
int[] arr2 = new int[3];//创建数组,长度为3
 
System.out.println(arr1);//打印数组的地址值
System.out.println(arr2);
 
arr1[0] = 10;//给第一个数组中第一个元素赋值
arr2[1] = 20;//给第二个数组中第二个元素赋值
 
System.out.println(arr1[0]);
System.out.println(arr1[1]);
System.out.println(arr1[2]);
 
System.out.println("--------------------------------------");
 
System.out.println(arr2[0]);
System.out.println(arr2[1]);
System.out.println(arr2[2]);
}
}

###04.19_Java语言基础(数组的内存图解3三个引用两个数组)(了解)

* A:画图演示

* 三个引用，有两个数组的引用指向同一个地址

案例：

//三个引用两个数组

class Demo5_Array {
public static void main(String[] args) {
int[] arr1 = new int[3];
int[] arr2 = new int[5];
int[] arr3 = arr2;
 
System.out.println(arr1);
System.out.println(arr2);
System.out.println(arr3);
 
arr1[0] = 10;
arr1[1] = 20;
 
arr2[1] = 30;
arr3[1] = 40;
arr3[2] = 50;
 
System.out.println(arr1[0]);
System.out.println(arr1[1]);
System.out.println(arr1[2]);
System.out.println("-------------------------------");
System.out.println(arr2[0]);
System.out.println(arr2[1]);
System.out.println(arr2[2]);
System.out.println(arr2[3]);
System.out.println(arr2[4]);
System.out.println("-------------------------------");
System.out.println(arr3[0]);
System.out.println(arr3[1]);
System.out.println(arr3[2]);
System.out.println(arr3[3]);
System.out.println(arr3[4]);
}
}

###04.20_Java语言基础(数组的初始化静态初始化及内存图)(掌握)

* A:静态初始化的格式：

* 格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};

* 简化格式：

* 数据类型[] 数组名 = {元素1,元素2,…};

* B:案例演示

* 对数组的解释

* 输出数组名称和数组元素

* C:画图演示

* 一个数组

案例：

class Demo6_Array {
public static void main(String[] args) {
//数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
//int[] arr = new int[5]{11,22,33,44,55};//不允许动静结合
int[] arr2 = {11,22,33,44,55};//静态初始化的简写形式
 
//int[] arr;//声明数组引用
//arr = new int[]{11,22,33,44,55};
 
//int[] arr2;
//arr2 = {11,22,33,44,55};//简写形式声明和赋值在同一行，这样写会报错
 
System.out.println(arr2);
System.out.println(arr2[4]);
}
}

###04.21_Java语言基础(数组操作的两个常见小问题越界和空指针)(掌握)

* A:案例演示

* a:ArrayIndexOutOfBoundsException:数组索引越界异常

* 原因：你访问了不存在的索引。

* b:NullPointerException:空指针异常

* 原因：数组已经不在指向堆内存了。而你还用数组名去访问元素。

案例：

class Demo7_Exception {
public static void main(String[] args) {
int[] arr = new int[5];//0x0011
//System.out.println(arr[-1]);//当访问数组中不存在的索引,会出现索引越界异常
 
arr = null;
System.out.println(arr[0]);//当数组引用赋值为null,再去调用数组中的元素就会出现空指针异常
}
} 

  

###04.22_Java语言基础(数组的操作1遍历)(掌握)

* A:案例演示

* 数组遍历：就是依次输出数组中的每一个元素。

* 数组的属性:arr.length数组的长度

* 数组的最大索引:arr.length - 1;

案例：

class Demo8_Array {
public static void main(String[] args) {
int[] arr = {11,22,33,44,55};
 
/*System.out.println(arr[0]);//这么做代码的复用性太差，我们学习了循环
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);
System.out.println(arr[4]);*/
for (int i = 0;i < 5 ;i++ ) {
System.out.println(arr[i]);
}
System.out.println("---------------");
//arr.length 代表的是数组的长度
System.out.println(arr.length);
for (int i = 0;i < arr.length ;i++ ) {
System.out.println(arr[i]);
}
 
int[] arr2 = {3,4,5};
print(arr2);
}
 
/*
数组的遍历
1,返回值类型void
2,参数列表int[] arr
*/
 
public static void print(int[] arr) {
for (int i = 0;i < arr.length ;i++ ) {
System.out.print(arr[i] + " ");
}
}
}

###04.23_Java语言基础(数组的操作2获取最值)(掌握)

* A:案例演示

* 数组获取最值(获取数组中的最大值最小值)

案例：

class Demo9_Array {
public static void main(String[] args) {
int[] arr = {33,77,22,44,55};
int max = getMax(arr);
System.out.println(max);
}
 
/*
获取数组中最大值
1,返回值类型int
2,参数列表int[] arr
*/
 
public static int getMax(int[] arr) {
int max = arr[0];
for (int i = 1;i < arr.length ;i++ ) {//从数组的第二个元素开始遍历
if (max < arr[i]) {//如果max记录的值小于的数组中的元素
max = arr[i];//max记录住较大的
}
}
 
return max;
}
}

###04.24_Java语言基础(数组的操作3反转)(掌握)

* A:案例演示

* 数组元素反转(就是把元素对调)

案例：

class Demo10_Array {
public static void main(String[] args) {
int[] arr = {11,22,33,44,55};
reverseArray(arr);
print(arr);
}
 
/*
数组元素反转
1,明确返回值类型void
2,明确参数列表int[] arr
*/
 
public static void reverseArray(int[] arr) {
for (int i = 0;i < arr.length / 2 ; i++) {
//arr[0]和arr[arr.length-1-0]交换
//arr[1]和arr[arr.length-1-1]交换
//arr[2]和arr[arr.lentth-1-2]
//...
 
int temp = arr[i];
arr[i] = arr[arr.length-1-i];
arr[arr.length-1-i] = temp;
}
        }
        public static void reverseArray1(int[] arr) {
for(int i=0,j=arr.length-1;i<=j;i++,j--) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
 
/*
数组遍历
1,明确返回值类型void
2,明确参数列表int[] arr
*/
 
public static void print(int[] arr) {
for (int i = 0;i < arr.length ;i++ ) {//遍历数组中的每一个元素
System.out.print(arr[i] + " ");//打印在控制台
}
}
}

###04.25_Java语言基础(数组的操作4查表法)(掌握)

* A:案例演示

* 数组查表法(根据键盘录入索引,查找对应星期)

案例：

import java.util.Scanner;
class Demo11_Array {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入对应的星期范围在1-7");
int week = sc.nextInt();
 
System.out.println("星期" + getWeek(week));
}
 
/*
根据索引返回对应的星期
1,返回值类型char
2,参数列表int week
*/
 
public static char getWeek(int week) {
char[] arr = {' ','一','二','三','四','五','六','日'};//定义了一张星期表
return arr[week];//通过索引获取表中的元素
}
}

###04.26_Java语言基础(数组的操作5基本查找)(掌握)

* A:案例演示

* 数组元素查找(查找指定元素第一次在数组中出现的索引)

案例：

class Demo12_Array {
public static void main(String[] args) {
int[] arr = {11,22,33,44,55,66,77};
int index = getIndex(arr,88);
System.out.println(index);
}
 
/*
查找元素索引
1,返回值类型int
2,明确参数列表,int[] arr,int value
*/
 
public static int getIndex(int[] arr,int value) {
for (int i = 0;i < arr.length ;i++ ) {//数组的遍历
if (arr[i] == value) {//如果数组中的元素与查找的元素匹配
return i;
}
 
}
return -1;
}
}

###04.27_day04总结

把今天的知识点总结一遍。