2023.3.27学习Java打卡
Java方法
#方法是解决一类问题的步骤的有序组合
#方法包含于类或对象中
#方法在程序中被创建，在其他地方被引用
例：
public class demo1 {
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 返回值; }
-
方法调用
调用方法：对象名.方法名(实参列表)
-
若方法返回一个值：
int num = max(30, 40); -
若方法返回值是void：
System.out.println("xxxxxxxx");调用一定是一条语句。
Java都是值传递！！
-
-
方法的重载：在一个类中，方法名相同，形参不同的函数。
规则：
- 方法名必须相同
- 参数列表必须不同（个数，类型，参数排列顺序不同等）
- 方法返回类型可相同可不同
- 仅返回类型不同，不可成为方法重载
-
命令行传参
-
可变参数
规则：
- 在指定参数类型后加一个省略号(...)
- 一个方法中只能指定一个可变参数，他必须是方法的最后一个参数，任何普通参数必须在他前面声明。
例：
public class Demo1 { public static void main(String[] args) { Demo1 demo1 = new Demo1(); demo1.test(1,2,56,51,3,8); } public void test(int... i){ System.out.println(i[0]); System.out.println(i[1]); System.out.println(i[2]); System.out.println(i[3]); System.out.println(i[4]); System.out.println(i[5]); } -
递归
小练习：写一个计算器，要求实现加减乘除功能，并且能循环接受新的数据。
以下是我的代码：
import java.util.Scanner;
public class Demo1 {
public static void main(String[] args) {
Demo1 demo1 = new Demo1();
for (int i = 0; i < 1000; i++) {
System.out.println("您需要做什么计算？加法、减法、乘法、除法。");
System.out.println("完成请输入退出");
Scanner scanner = new Scanner(System.in);
String need = scanner.nextLine();
if(need.equals("加法")){
double x = scanner.nextDouble();
double y = scanner.nextDouble();
demo1.add(x, y);
}else if (need.equals("减法")) {
double x = scanner.nextDouble();
double y = scanner.nextDouble();
demo1.sub(x, y);
}else if (need.equals("乘法")) {
double x = scanner.nextDouble();
double y = scanner.nextDouble();
demo1.multi(x, y);
}else if (need.equals("减法")) {
double x = scanner.nextDouble();
double y = scanner.nextDouble();
demo1.div(x, y);
} else if (need.equals("退出")) {
break;
}
}
}
public void add(double a, double b){
double sum = 0;
sum = a + b;
System.out.println(a + "+" + b + "=" + sum);
}
public void sub(double a, double b){
double sum = 0;
sum = a - b;
System.out.println(a + "-" + b + "=" + sum);
}
public void multi(double a, double b){
double sum = 0;
sum = a * b;
System.out.println(a + "*" + b + "=" + sum);
}
public void div(double a, double b){
double sum = 0;
sum = a / b;
System.out.println(a + "/" + b + "=" + sum);
}
}
还请各位大神亮出你们的代码，我的代码好像太啰嗦了。
数组
定义：数组是相同类型数据的集合，是按照一定次序排列相同类型的若干数据的组合。其中每一个数据被称为一个数组元素，每个数组元素可以通过一个下标来访问他们。
-
数组声明创建
//声明数组 dataType[] arrayRefVar; //首选方法 dataType arrayRefVar[]; //效果相同，但并非首选 //使用new操作符创建数组 dataType[] arrayRefVar = new dataType[arraySize]; //获取数组长度 arrays.length数组特点：
- 其长度确定，一旦被创建，大小不可改变。
- 其元素必须是相同类型，不可混合其他类型。
- 数组中的元素可以是任何数据类型，包括基本类型和引用类型。
- 数组变量属于引用类型，数组也可看作为对象，数组中的每个元素相当于该对象的成员变量。数组对象本身是在堆中。
内存分析
-
堆
- 存放new的对象和数组；可被所有线程共享
-
栈
- 存放基本变量类型（包括这个基本变量的具体数值）；
- 引用对象的变量（会存放这个引用在堆里面的集体地址）
-
方法区
- 可以被所有的线程共享
- 包含所有的class和static变量
三种初始化
-
静态初始化
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; -
数组的默认初始化
数组是引用类型，其元素相当于类的实例变量，因此，数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。
数组边界
- 下标的合法区间：[0, length-1]
- 越界则报ArrayIndexOutOfBoundsException。
数组使用
- for-each循环
- 数组作方法入参
- 数组作返回值
多维数组
-
二维数组
int a[][] = new int[2][5]
Arrays类
- 可以用提供的工具类Arrays，对数据对象进行一些基本操作。
- Arrays类中的方法都是static修饰的静态方法，可以直接使用类名调用。
冒泡排序
import java.util.Arrays;
public class MaoPaoPaiXu {
public static void main(String[] args) {
int[] a = {1,2,3,5,7,9,22,44,63,75};
int[] sort = sort(a);
System.out.println(Arrays.toString(sort));
}
public static int[] sort(int[] array){
int temp = 0;
for (int i = 0; i < array.length; i++) {
boolean flag = false;//通过flag标识符减少没有意义的比较
for (int j = 0; j < array.length-1-i; j++) {
if (array[j+1] > array[j]){
temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
flag = true;
}
}
if(flag == false){
break;
}
}
return array;
}
}
稀疏数组
当数组中大部分元素为0，或为同一值时，可用稀疏数组来保存。
处理方式：
-
记录数组一共有几行几列，有多少不同值。
-
把具有不同值的元素和行列和值记录在小规模数组中，从而缩小程序的规模。
例：
public class XiShuMetrix { public static void main(String[] args) { int[][] array1 = new int[11][11]; array1[1][2] = 1; array1[2][3] = 1; System.out.println("输出原始数组："); for (int[] ints : array1) { for (int anInt : ints) { System.out.print(anInt+"\t"); } System.out.println(); } //转换为稀疏数组 int sum = 0; for (int i = 0; i < 11; i++) { for (int j = 0; j < 11; j++) { if (array1[i][j] != 0) { sum++; } } } System.out.println("有效值个数为："+sum); //创建一个稀疏数组 int[][] array2 = new int[sum+1][3]; array2[0][0] = 11; array2[0][1] = 11; 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 i = 0; i < array2.length; i++) { System.out.println(array2[i][0] + "\t" + array2[i][1] + "\t" + array2[i][2] + "\t"); } //还原稀疏数组 //读取稀疏数组 int[][] array3 = new int[array2[0][0]][array2[0][1]]; //给其中元素还原值 for (int i = 1; i < array2.length; i++) { array3[array2[i][0]][array2[i][1]] = array2[i][2]; } System.out.println("输出还原数组："); for (int[] ints : array1) { for (int anInt : ints) { System.out.print(anInt+"\t"); } System.out.println(); } } }
面向对象编程
-
本质：以类的方式组织代码，以对象的方式组织（封装）数据
-
三大特性：
- 封装
- 继承
- 多态
-
类：是一种抽象的数据类型，是对事物整体的抽象描述，不能代表某一个具体事物。
-
对象：是抽象概念的具体实例。
创建与初始化对象
- 使用new关键字创建对象
- 使用new关键字创建对象时，除了分配内存空间外，还会给已创建的对象进行默认的初始化，以及类中构造器的调用。
- 类中的构造器也称为构造器也称为构造方法，是创建对象时必须要调用的。
- 构造器特点：
- 必须和类的名字相同；
- 必须没有返回值，也不能写void。
- 构造器特点：