Day01 P1-P10
/*
创建一个原始二维数组11*11
0：没有子 1：黑子 2：白子
*/
import java.util.Scanner;
public class SparseArray {
public static void main(String[] args) {
int chessArr1[][] = new int[11][11];
chessArr1[1][2] = 1;
chessArr1[2][3] = 2;
System.out.println("原始二维数组：");
for(int[] row : chessArr1){
for(int data : row){
System.out.printf("%d\t", data);
}
System.out.println();
}
//二维数组 转 稀疏数组
//先遍历二维数组，得到非零数据个数
int sum = 0;
for (int i = 0; i < 11; i++) {
for (int j = 0; j < 11; j++) {
if (chessArr1[i][j] != 0) {
sum++;
}
}
}
System.out.println(sum);
//创建对应稀疏数组
int sparseArr[][] = new int[sum + 1][3];
//给稀疏数组赋值
sparseArr[0][0] = 11;
sparseArr[0][1] = 11;
sparseArr[0][2] = sum;
//遍历二维数组，将非零值放入稀疏数组中
int count = 0;//用于记录第几个非零数据
for (int i = 0; i < 11; i++) {
for (int j = 0; j < 11; j++) {
if (chessArr1[i][j] != 0) {
count++;
sparseArr[count][0] = i;
sparseArr[count][1] = j;
sparseArr[count][2] = chessArr1[i][j];
}
}
}
//输出稀疏数组
System.out.println("稀疏数组：");
for (int i = 0; i < sparseArr.length; i++) {
System.out.printf("%d\t%d\t%d\t\n",sparseArr[i][0],sparseArr[i][1],sparseArr[i][2]);
}
System.out.println();
//稀疏数组恢复成二维数组
int chessArr2[][] = new int[sparseArr[0][0]][sparseArr[0][1]];
System.out.println();
//从稀疏数组的第二行开始
for (int i = 1; i < sparseArr.length; i++) {
chessArr2[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
}
for(int[] row : chessArr2){
for(int data : row){
System.out.printf("%d\t", data);
}
System.out.println();
}
}
}
Day07
匿名对象：
没有显时名称
匿名对象只能调用一次
匿名对象的使用：
package day07;
/**
* @author SunWenhao
* @create 2021/8/14
*/
public class InstanceTest {
public static void main(String[] args) {
Phone p = new Phone();
p.playGame();
p.sendEmail();
//匿名对象
new Phone().sendEmail();
new Phone().playGame();
new Phone().price = 1999;
new Phone().showPrice();//和上方的对象不一样
PhoneMall mall = new PhoneMall();
//mall.show(p);
mall.show(new Phone());
}
}
class Phone{
double price;
public void sendEmail(){
System.out.println("看电影");
}
public void playGame(){
System.out.println("玩游戏");
}
public void showPrice(){
System.out.println("手机价格为：" + price);
}
}
class PhoneMall{
public void show(Phone phone){
phone.sendEmail();
phone.playGame();
}
}
自定义数组工具类：
方法：
方法的重载
可变形参的方法
方法参数的值传递机制*
递归方法
重载：
定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
两同一不同：同一个类、同一个方法名、参数列表不同，参数个数不同
判断是否是重载：
跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系
总结："两同一不同":同一个类、相同方法名
参数列表不同：参数个数不同，参数类型不同
在通过对象调用方法时，如何确定指定方法：
方法名（可能有重载）---参数列表
package day07;
/**
* @author SunWenhao
* @create 2021/8/15
*/
public class OverLoadExer {
public static void main(String[] args) {
OverLoadExer test = new OverLoadExer();
test.mOL(2);
test.mOL(2,3);
test.mOL("Hello");
System.out.println(test.max(3.14,8.56,6.98));
}
public void mOL(int i){
System.out.println(i * i);
}
public void mOL(int i,int j){
System.out.println(i * j);
}
public void mOL(String s){
System.out.println(s);
}
public int max(int i,int j){
return (i > j)? i : j;
}
public double max(double d1,double d2){
return (d1 > d2)? d1 : d2;
}
public double max(double d1,double d2,double d3){
double max = (d1 > d2)? d1 : d2;
return (max > d3)? max : d3;
}
} 可变个数形参：（JDK5.0新增）
格式：数据类型 ... 变量名
调用可变个数形参方法时，传入参数个数可以是0、1、2 ... ... 多个；
可变个数形参方法与本类中同一个类、同一个方法名、参数列表不同，参数个数不同方法之间构成重载；
可变个数形参方法必须声明在末尾
package day07;
/**
* @author SunWenhao
* @create 2021/8/15
*/
public class MethodArgsTest {
public static void main(String[] args) {
MethodArgsTest test = new MethodArgsTest();
test.show(12);
test.show("Hello");
test.show("Hello1","Hello2");
}
public void show(int i){
}
public void show(String s){
}
public void show(String ... strs){
for (int i = 0; i < strs.length; i++) {
System.out.println(strs[i]);
}
}
//不可以共存
// public void show(String[] strs){
//
// }
}
方法参数的值传递机制：
如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值
如果参数时基本数据类型，此时实参赋给形参的时实参真实存储的数据值
方法形参传递机制：值传递
形参：方法定义时小括号内的参数
实参：给形参赋的值
值传递机制？：
package day07;
/**
* @author SunWenhao
* @create 2021/8/15
*/
//public class ValueTransferTest {
// public static void main(String[] args) {
// int m = 10;
// int n = m;
// System.out.println("m:"+ m + "," + "n:" + n);
// n = 20;
// System.out.println("m:"+ m + "," + "n:" + n);
//
//
// System.out.println();
// Order o1 = new Order();
// o1.orderId = 1001;
// Order o2 = o1;
// System.out.println(o1.orderId + " " + o2.orderId);
// o2.orderId = 1002;
// System.out.println(o1.orderId + " " + o2.orderId);
//方法形参传递机制：值传递
//形参：方法定义时小括号内的参数
//实参：给形参赋的值
public class ValueTransferTest {
public static void main(String[] args) {
ValueTransferTest test = new ValueTransferTest();
int m = 10;
int n = 20;
System.out.println("m:"+ m + "," + "n:" + n);
int temp = m;
m = n;
n = temp;
System.out.println("m:"+ m + "," + "n:" + n);
test.swap(m,n);
System.out.println("m:"+ m + "," + "n:" + n);//这里的m、n仍然是main方法中的，所以不会变
}
public void swap(int m,int n){
int temp = m;
m = n;
n = temp;
System.out.println("m:"+ m + "," + "n:" + n);
}
}
递归（了解）：
在一个方法体中自己调自己
方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。
package day07;
/**
* @author SunWenhao
* @create 2021/8/15
*/
//计算1-100所有自然数的和
public class Recursion {
public static void main(String[] args) {
int sum = 0;
Recursion test = new Recursion();
// for (int i = 0; i < 100; i++) {
// sum = sum + i;
// }
sum = test.getSum(20);
System.out.println(sum);
}
public int getSum(int n){
if (n == 1){
return 1;
}else {
return n + getSum(n - 1);
}
}
}
斐波那契数列：
package day07;
/**
* @author SunWenhao
* @create 2021/8/15
*/
public class Fibonacci {
public static void main(String[] args) {
Fibonacci test = new Fibonacci();
System.out.println(test.Calculate(10));
}
public int Calculate(int n){
if (n == 1){
return 1;
}else if (n == 2){
return 1;
}else{
int fibonacci;
fibonacci = Calculate(n - 1) + Calculate(n -2);
return fibonacci;
}
}
}
京公网安备 11010502036488号