DAY 09 10 11
文章目录
1. 方法
1.1 何为方法
- Java方法是语句的集合，它们在一起执行一个功能。
【方法是解决一类问题的步骤的有序组合】
【方法包含于类或对象中】
【方法在程序中被创建，在其他地方被引用】 - 设计方法的原则：方法的本意是功能块，就是实现某个功能的语句块的集合。我们设计方法的时候，最好保持方法的原子性，就是一个方法只完成一个功能，这样利于我们后期的扩展。
- 回顾方法的命名规则：首字母小写，驼峰原则。
1.2 方法的定义
-
Java的方法类似于其他语言的函数，是一段用来完成特定功能的代码片段，一般情况下，定义一个方法包含以下语法：
-
方法包含一个方法头和一个方法体。下面是一个方法的部分：
修饰符：修饰符，这是可选的，告诉编译器如何调用方法。定义了该方法的访问类型。 -
返回值类型：方法可能会返回值。returnValueType 是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnValueType 是关键字void。
-
方法名：是方法的实际名称。方法名和参数表共同构造方法名。
-
参数类型：参数是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数、参数是可选的，方法可以不包含任何参数。
package com.wuyi.www.method; public class AddDemo01 { //main方法 public static void main(String[] args) { //实际参数，实际调用传递给他的参数 int sum = add(1,2); System.out.println(sum); } //加法 //形式参数，用来定义作用的 public static int add(int a,int b){ return a+b; } }形式参数：在方法被调用时用于接收外界输入的数据。 实 参： 调用方法时实际传递给方法的数据。 方 法 体：方法体包含具体的语句，定义该方法的功能。 -
语法：
修饰符 返回值类型 方法名（参数类型 参数名）{ 方法体 return 返回值； }
1.3 方法的调用
- 调用方法：对象名.方法名（实参列表）
- Java支持两种调用方法的方式，根据方法是否返回值来选择。
- 当方法返回一个值的时候，方法调用通常被当作一个值。
int larger = max (30,40); - 如果方法返回值时void，方法调用一定是一条语句。
System.out.println(“hello,world”); - 课后拓展了解：值传递（Java属于值传递） 和 引用传递
package com.wuyi.www.method;
public class Demo04 {
public static void main(String[] args) {
//调用可变参数的方法
printMax(34,3,3,2,56.5);
printMax(new double[]{1,2,3});
}
public static void printMax (double...numbers){
if (numbers.length == 0){
System.out.println("No argument passed");
return;
}
double result = numbers[0];
//排序
for (int i = 1; i < numbers.length; i++) {
if (numbers[i] > result){
result = numbers[i];
}
}
System.out.println("The max value is "+result);
}
}
1.4 方法重载
- 重载就是在一个类中，有相同的函数名称，但形式不同的函数
- 方法的重载的规则：
A.方法名称必须相同；
B.参数列表必须不同（个数不同、或类型不同、参数排列顺序不同等）；
C.方法的返回类型可以相同也可以不同；
D.仅仅返回类型不同不足以称为方法的重载。 - 实现理论：
方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错。
1.5 可变参数
- JDK1.5开始，Java支持传递同类型的可变参数给一个方法。
- 在方法声明中，在指定参数类型后加一个省略号（…）。
- 在一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数都必须在它之前声明。
package com.wuyi.www.method;
public class MaxDemo02 {
public static void main(String[] args) {
int max = max(20.0,30.0);
System.out.println(max);
}
public static int max(int num1,int num2){
int result = 0;
if (num1==num2){
System.out.println("两者相等");
return 0; //终止方法
}
if (num1>num2){
result = num1;
}else{
result = num2;
}
return result;
}
public static int max(double num1,double num2){
int result = 0;
if (num1==num2){
System.out.println("两者相等");
return 0; //终止方法
}
if (num1>num2){
result = (int) num1;
}else{
result = (int) num2;
}
return result;
}
}
1.6 递归思想
package com.wuyi.www.method;
public class Demo05 {
public static void main(String[] args) {
//递归思想
System.out.println(f(10));
}
//阶乘
//1! 1
//5！ 5*4*3*2*1
public static double f(int n){
if (n == 1){
return 1;
}else {
return n*f(n-1);
}
}
}
1.7 练习
写一个计算器，要求实现加减乘除功能，并且能够循环接收新的数据，通过用户交互实现。
思路：
- 写4个方法：加减乘除；
- 利用循环+switch进行用户交互；
- 传递需要操作的两个数；
- 输出结果。
package com.wuyi.www.method;
import java.util.Scanner;
public class Demo06 {
public static void main(String[] args) {
//从键盘输入数据
Scanner scanner = new Scanner(System.in);
System.out.println("请输入数据：");
while (scanner.hasNextDouble()) {
double num1 = scanner.nextDouble(); //输入num1
double num2 = scanner.nextDouble(); //输入num2
//String str = scanner.nextLine(); //输入算术符号
//判断加减乘除
String arithmetic = "multiply";
switch (arithmetic) {
case "add":
double result1 = add(num1,num2);
System.out.println(result1);
break;
case "subtract":
double result2 = subtract(num1,num2);
System.out.println(result2);
break;
case "multiply":
double result3 = multiply(num1,num2);
System.out.println(result3);
break;
case "divide":
double result4 = divide(num1,num2);
System.out.println(result4);
break;
default:
System.out.println("抱歉无法识别！");
}
}
scanner.close();
}
//加法
public static double add(double num1, double num2){
return num1+num2;
}
//减法
public static double subtract(double num1, double num2){
return num1-num2;
}
//乘法
public static double multiply(double num1, double num2){
return num1*num2;
}
//除法
public static double divide(double num1, double num2){
return num1/num2;
}
}
2. 数组
2.1 数组的声明与创建
-
首先必须声明数组变量，才能在程序中使用数组。
-
语法：
dataType[] arrayRefVar; //首选的方法 dataType[] arrayRefVar; //效果相同，但不是首选方法 -
Java语言使用new操作符来拆创建数组，语法如下：
dataType[] arrayRefVar = new dataType[arraySize]; -
数组的元素是通过索引访问的，数组索引从0开始。
-
获取数组长度：arrays.length
package com.wuyi.www.array;
public class ArrayDemo01 {
//变量类型 变量名字 = 变量值
//数组类型
public static void main(String[] args) {
int[] nums; //1.声明一个数组
nums = new int[10]; //2.创建一个数组
//3.给数组中元素赋值
nums[0] = 1;
nums[1] = 2;
nums[2] = 3;
nums[3] = 4;
nums[4] = 5;
nums[5] = 6;
nums[6] = 7;
nums[7] = 8;
nums[8] = 9;
nums[9] = 10;
System.out.println(nums[2]);
int sum = 0;
//数组长度：arrays.length
for (int i = 0; i < nums.length; i++) {
sum = sum + nums[i];
}
System.out.println("数组总和为："+sum);
}
}
2.2 内存分析
Java内存：
-
堆：存放new的对象和数组
可以被所有的线程共享，不会存放别的对象引用
-
栈：存放基本变量类型（会包含这个基本类型的具体数值）
引用对象的变量（会存放这个引用在堆里面的具体地址）
3.方法区：可以被所有的线程共享
包含了所有的class和static变量
2.3 数组初始化
- 静态初始化：
int[ ] a = {1,2,3};
Man[ ] mans = {new Man(1,1),new Man(2,2)}; - 动态初始化：
int[ ] a = new int[2];
a[0] = 1;
a[1] = 2; - 数组的默认初始化：
数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量一样的方式被隐式初始化。
2.4 数组的四个基本特点
- 其长度是确定的。数组一旦被创建，它的大小就是不可以该改变的。
- 其元素必须是相同类型，不允许出现混合类型。
- 数组中的元素可以是任何数据类型，包括基本类型和引用类型。
- 数组变量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。
数组本身就是对象，Java中的对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。
小结：
1.数组是相同数据类型（数组类型可以是任意类型）的有序集合;
2.数组也是对象。数组元素相当于对象的成员变量;
3.数组长度是确定的，不可变的。
数组的使用：
1. 普通的for循环
2.for-each循环
3.数组作方法入参
4.数组作返回值
2.2 反转数组、打印和遍历数组元素
反转打印数组：
package com.wuyi.www.array;
import org.w3c.dom.ls.LSOutput;
public class ArrayDemo02 {
public static void main(String[] args) {
//声明创建一个数组
int[] arrays = {1,2,3,4,5};
printArray(arrays);
int[] reverse = reverse(arrays);
printArray(reverse);
}
//反转数组
public static int[] reverse(int[] arrays){
int[] result = new int[arrays.length];
//反转操作
for (int i = 0, j = arrays.length - 1; i <arrays.length ; i++, j--) {
result[j] = arrays[i];
}
return result;
}
//打印数组元素
public static void printArray(int[] arrays){
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i]+"\t");
}
System.out.println();
}
}
遍历数组元素：
package com.wuyi.www.array;
public class ArrayDemo03 {
public static void main(String[] args) {
//创建一个数组
int[][] array = {{1,2},{3,4},{4,5},{5,6}};
//遍历素组元素
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++){
System.out.print(" "+array[i][j]+"\t");
}
System.out.println();
}
}
}
2.3 填充数组
package com.wuyi.www.array;
import java.util.Arrays;
public class ArrayDemo04 {
public static void main(String[] args) {
int[] a = {1,2,3,4,2342,5656,67,3,35567,14};
System.out.println(a); //[I@6e8dacdf
//打印数组元素
System.out.println(Arrays.toString(a));
Arrays.sort(a); //对数组进行排序
System.out.println(Arrays.toString(a));
//数组填充
Arrays.fill(a,2);
System.out.println(Arrays.toString(a));
Arrays.fill(a,2,5,0);
System.out.println(Arrays.toString(a));
}
}
2.4 冒泡排序算法
- 冒泡排序无疑是最为出名的排序算法之一，总共有八大排序算法。
- 冒泡的代码相当简单，两层循环，外层冒泡轮数，里层依次比较。
- 看到嵌套循环，这个算法的时间复杂度为O(n^2)。
package com.wuyi.www.array;
import java.util.Arrays;
public class ArrayDemo05 {
public static void main(String[] args) {
int[] a = {12,234,2,4,24,5,124234,45,876,57,0};
sort(a);
System.out.println(Arrays.toString((a)));
}
/*冒泡排序
1. 比较数组中两个相邻的元素，如果第一个元素比第二个元素大，我们就交换它们的位置；
2. 每次比较都会产生一个最大或者最小的数字；
3. 下一轮则可以少一轮排序；
4. 依次循环，直到结束;
5. 时间复杂度O(n^2).
*/
public static int[] sort(int[] array){
int temp = 0; //临时变量
//外层循环，判断循环要走多少次
for (int i = 0; i < array.length-1; i++) {
boolean flag = false; //优化算法，通过flag标识符减少没有意义的比较
//内层循环，比较判断两个数字，如果第一个数字比第二个数字大，则交换位置
for (int j = 0; j < array.length-1-i; j++) {
if(array[j]>array[j+1]){
temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
flag = true;
}
}
if(flag == false){
break;
}
}
return array;
}
}
2.5 稀疏数组
-
当一个数组中大部分元素为0，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。
-
稀疏数组的处理方式是：
记录数组一共有几行几列，有多少个不同值；
把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模。
package com.wuyi.www.array;
public class ArrayDemo06 {
public static void main(String[] args) {
//1.创建一个二维数组 11*11 0：没有棋子 1：黑子 2：白子
int[][] array1 = new int[11][11];
array1[1][2] = 1;
array1[2][3] = 2;
//输出原始素组
System.out.println("输出原始数组");
for (int[] ints : array1){
for (int anInt : ints){
System.out.print(anInt+"\t");
}
System.out.println();
}
//2.转换为稀疏数组保存，并获取有效值个数
int sum = 0;
for (int i = 0; i < array1.length; i++) {
for (int j = 0; j < array1[i].length; j++) {
if (array1[i][j]!=0) {
sum++;
}
}
}
System.out.println("有效值个数："+sum);
//3.创建一个稀疏数组的数组
int[][] array2 = new int[sum+1][3];
array2[0][0] = array1.length;
array2[0][1] = array1.length;
array2[0][2] = sum;
//遍历二维数组，将非零的值，存放到稀疏数组中
int count = 0;
for (int i = 0; i < array1.length; i++) {
for (int j = 0; j < array1[i].length; j++) {
if(array1[i][j]!=0){
count++;
array2[count][0] = i;
array2[count][1] = j;
array2[count][2] = array1[i][j];
}
}
}
//输出稀疏数组
System.out.println("输出稀疏数组");
for (int[] ints: array2){
for(int anInt: ints){
System.out.print(anInt+"\t");
}
System.out.println();
}
//3.还原原始数组
int[][] array3 = new int[array2[0][0]][array2[0][1]];
System.out.println("输出还原数组");
for (int i = 1; i < array2.length; i++) {
array3[array2[i][0]][array2[i][1]] = array2[i][2];
}
//输出还原数组
for (int[] ints: array3){
for(int anInt: ints){
System.out.print(anInt+"\t");
}
System.out.println();
}
}
}
/*
输出原始数组
0 0 0 0 0 0 0 0 0 0 0
0 0 1 0 0 0 0 0 0 0 0
0 0 0 2 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
有效值个数：2
输出稀疏数组
11 11 2
1 2 1
2 3 2
输出还原数组
0 0 0 0 0 0 0 0 0 0 0
0 0 1 0 0 0 0 0 0 0 0
0 0 0 2 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0
*/
2816
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
