JavaSE基础03
一、Java的方法
1. 什么是方法?
-
System.out.println();
-
类 + 对象(名) + 方法(名)
-
Java方法是语句的集合，他们在一起执行一个功能
- 方法是解决一类问题步骤的有序组合
- 方法包含于类或者对象中
- 方法在程序中被创建，在其他地方被引用
-
设计方法的原则：
- 保持方法的原子性 一个方法只完成一个功能，这样利于我们后期拓展
public class Way_01 {
public static void main(String[] args){
way_01();
}
public static void way_01() {
for(int i = 1;i<= 1000;i++){
if(i % 5 == 0) {
System.out.print(i + "\t");
}
if(i % (5 * 3) == 0) {
System.out.println();
}
}
}
}
2. 方法的定义和调用
修饰符 方法返回值类型 方法名 (参数类型 参数名) {
//方法体
return 返回值;
}
public class Compare_number {
public static void main(String[] args) {
compare(111,123);
}
public static int compare(int number_a, int number_b) {
if(number_a == number_b){
System.out.println("您输入的两个数据大小相等");
return 0;
}
if(number_a > number_b) {
return number_a;
}else {
return number_b;
}
}
}
3. 方法的重载
- 在一个类中，有相同的方法名称，但是形参不同的方法
方法的重载的规则：
- 方法名称必须相同
- 参数列表必须不同(个数不同、或类型不同、参数排列顺序不同等)
- 方法的返回值类型可以相同也可以不相同
- 仅仅返回值类型不同不足以构成方法的重载
简单点说就是一个类中用了两个方法，方法的名称相同，参数列表不相同
public class Compare_number {
public static void main(String[] args) {
int max = compare(111,123);
System.out.println(max);
}
public static int compare(int number_a, int number_b) {
int result = 0;
if(number_a == number_b){
System.out.println("您输入的两个数据大小相等");
return 0;
}
if(number_a > number_b) {
result = number_a;
}else {
result = number_b;
}
return result;
}
public static double compare(double number_a, double number_b) {
double result = 0.0;
if(number_a == number_b) {
System.out.println("您输入的两个数据大小相等");
return 0.0;
}
if(number_a > number_b) {
result = number_a;
}else {
result = number_b;
}
return result;
}
public static int compare(int number_a,int number_b,int number_c) {
int result = 0;
if (number_a > number_b){
if (number_a > number_c){
result = number_a;
}else {
result = number_c;
}
}
if (number_b > number_a){
if (number_b > number_c){
result = number_b;
}else {
result = number_c;
}
}
return result;
}
}
方法的返回值类型如果是void的话是可以直接输出在控制台的
方法的返回值类型如果是int，String，double等非void类型 方法在调用的时候要给一个变量名称并输出；
4. 命令行传参
compile 编译
打开cmd命令行
进入到包下面对java文件进行编译
把Demo.java 文件编译成class文件： javac Demo.java
回退到src目录下面 使用 cd ../ 进行回退
到src目录下面之后输入 java com.包名.包名.项目名 操作
public class CommandLine {
public static void main(String[] args){
for(int i = 0;i < args.length;i++){
System.out.println("args[" + i + "]" + args[i]);
}
}
}
5. 可变参数
注意：1. 在方法声明中，在指定参数类型后面加一个省略号(...)
2. 一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数都必须在它之前声明pu
public class Compare {
public static void main(String[] args[]){
Compare compare = new Compare();
compare.printMax(10.10,22.22,33.33);
}
public static void printMax(double... numbers) {
if(numbers.length == 0) {
System.out.println("No argument passed");
return;
}
double max = numbers[0];
//排序！
for(int i = 1;i < number.length;i++){
if(numbers[i] > max) {
max = numbers[i];
}
}
System.out.println("The max value is " + max);
}
}
二、递归
递归结构包括两个部分：
递归头：什么时候不调用自身方法。如果没有头，将陷入死循环
递归体：什么时候需要调用自身方法
//数的阶乘
public class Factorial {
public static void main(String[] args){
System.out.print("Please input the factorial number ：");
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
Factorial recursion = new Recursion();
int sum = recursion.factorial(n);
System.out.println("The factorial of " + n + "result is " + sum);
}
public static int factorial(int n){
if(n == 1){
return 1;
}else{
return n * recursion(n - 1);
}
}
}
三、Java数组
1. 数组的定义
- 数组是相同类型数据的有序集合
- 数组描述的是相同类型的若干数据，按照一定的先后次序排列组合而成
- 其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们
//声明数组变量的语法:
dataType[] arrayRefVar
int[] array_01
//java语言使用new操作符来创建数组：
dataType[] arrayRefVar = new dataType[arraySize];
int[] array_01 = new int[10];
//数组的元素是通过索引访问的，数组索引从0开始
//获取数组长度：
arrays.length
public class Array_01 {
public static void main(String[] args){
}
public static void arraySum(int[] arrayInt_01,n){
/* int[] arrayInt_01; //1. 声明一个数组
* arrayInt_01 = new int[n]; //1. 创建一个数组
*/
int[] arrayInt = new int[n];//1. 声明并创建一个数组
//2. 给数组中的元素赋值
// Scanner scanner = new Scanner(System.in);
// for(int i = 1;i <= arrayInt.length;i++){
// arrayInt[n] = scanner.nextInt();
//}
// System.out.println(arrayInt[n]);
arrayInt[0] = 1;
arrayInt[0] = 1;
arrayInt[0] = 1;
arrayInt[0] = 1;
arrayInt[0] = 1;
arrayInt[0] = 1;
arrayInt[0] = 1;
arrayInt[0] = 1;
arrayInt[0] = 1;
arrayInt[0] = 1;
//3. 计算(操作)
int sum = 0;
for(int i = 0;i <= 9;i++){
sum = sum + arrayInt[i];
}
System.out.println("The arrayInt sum is :" + sum);
}
}
2. Java内存分析
堆：存放new的对象和数组
可以被所有的线程共享，不会存放别的对象引用
栈：存放基本变量类型（会包含这个基本类型的具体数值）
引用对象的变量（会存放这个引用在堆里面的具体地址）
Java内存：
方法区：可以被所有线程共享
包含了所有的class和static变量
3. 三种初始化
//静态初始化：创建 + 赋值
int[] array_01 = {1,2,3};
Man[] mans = {new Man(1,1),new Man(2,2)};
//动态初始化：包含默认初始化
int[] array_01 = new int[2];
a[0] = 1;
a[1] = 2;
//数组的默认初始化：数组是引用类型，它的元素相当于类的实例化变量，因此数组一经分配空间，其中的每个元素 也被按照实例变量同样的方式 被隐式初始化
注意：没有赋值的其他数组元素默认初始化为0，（在控制台运行输出显示为0）
4. 数组的四个基本特点
- 数组长度确定，数组一但被创建，大小不可改变
- 数组元素必须是相同类型，不允许出现混合类型 （ 有序集合！）
- 数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型
- 数组变量属于引用类型，数组也可以看成是对象，数组中的每个变量 相当于该对象的成员变量
数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，
数组对象本身是在堆中的
5. 数组的使用
//查找数组中的最大元素
public class ArrayMax {
public static void main(String[] args) {
}
public static void printArrayMax(int[] array_01,n) {
int[] array_01 = new int[n];
for(int i = 0;i < array_01.length;i++){
array_01[i] = scanner.nextInt();
}
//打印数组
for(int i = 0; i <array_01.length;i++){
System.out.print(array_01[i] + " ");
}
//用For-Each循环进行打印数组元素
for(int array_01_element : array_01) {
System.out.print(array_01_element);
}
int max = array_01[0];
for(int i = 1;i < array_01.length;i++){
if(array_01[i] > max){
max = array_01[i];
}
}
System.out.println("max = " + max);
}
}
1. For-Each循环
public static int printArrayMax(int[] array_01,n) {
int[] array_01 = new int[n];
Scanner scanner = new Scanner(System.in);
for(int i = 0;i < array_01.length;i++){
array_01[i] = scanner.nextInt();
}
for(int array_01_element : array_01) {
System.out.print(array_01_element);
}
}
For-Each循环只能对数组进行打印，无法对数组进行操作
2. 数组作方法入参
public class Array_02 {
public static void main(String[] args) {
// int[] array_02 = new int[5];
//array_02[0] = 1;
//array_02[1] = 2;
//......
int[] array_02 = {1,2,3,4,5};
printArray_02(array_02);
}
public static void printArray_02(int[] array_02) {
for(int i = 0;i < array_02.length;i++){
System.out.print(array_02[i] + " ");
}
}
3. 数组作返回值
//反转数组
public class Array_03 {
public static void main(String[] args) {
// int[] array_02 = new int[5];
//array_02[0] = 1;
//array_02[1] = 2;
//......
int[] array_02 = {1,2,3,4,5};
int[] reverse = reverse(array_02);
printArray_02(reverse);
}
//打印数组
public static void printArray_02(int[] array_02) {
for(int i = 0;i < array_02.length;i++){
System.out.print(array_02[i] + " ");
}
//int[] 与 void ，int 相同 都是数据类型
//反转数组
public static int[] reverse(int[] array_02){
int[] result = new int[array_02.length];
//反转操作
for(int i = 0,j = result.length - 1;i < array_02.length;i++,j--){
result[j] = array_02[i];
}
return result;
}
}
6. 二维数组
public class TwoArray_02 {
public static void main(String[] args){
//[4][2]
//1,2 twoArray_02[0]
//2,3 twoArray_02[1]
//3,4 twoArray_02[2]
//4,5 twoArray_02[3]
int[][] twoArray_02 = {{1,2},{2,3},{3,4},{4,5}};
for(int i = 0;i < twoArray_02.length;i++){
for(int j = 0;j < twoArray_02[i].length;j++){
System.out.print(twoArray_02[i][j] + " ");
}
}
}
}
四、 Arrays类
-
Array类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而不用使用对象来进行调用 --(不用，不是不能)
-
具有以下常用功能
- 给数组(填充)赋值：fill 方法
- 对数组排序：sort方法，升序
- 比较数组：通过equals方法比较数组中元素值是否相等
- 查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找操作
//打印数组
//Arrays.toString
public class Array_03 {
public static void main(String[] args) {
int[] array_03 = {1,3,9,31,21,54,32,876,654};
// System.out.println(array_03); //打印的是数组这个对象的HashCode
//打印数组元素Array.toString
//System.out.println(Array.toString(array_03));
// printArray_03(array_03);
Array.sort(array_03);//对数组进行排序 sort 默认是升序
System.out.println(Array.toString(array_03));
Array.fill(array_03,100);//数组填充
Array.fill(array_03,2,4,100);
System.out.println(Array.toString(array_03));
}
public static void printArray_03(int[] array_03) {
for(int i = 0;i < array_03.length;i++){
if(i == 0){
System.out.print("[");
}
if(i == array_03.length - 1) {
System.out.print(array_03[i] + "]");
}else {
System.out.print(array_03[i] + ", ");
}
}
}
}
五、冒泡排序
- 冒泡排序代码：
- 两层循环，外层冒泡轮数
- 内层依次比较
//冒泡排序
//1. 比较数组中，两个相邻元素，如果第一个数比第二个数大，我们就交换他们的位置
//2. 每一次比较都会产生一个最大或者最小的数
//3. 下一次则可以少一次排序
//4. 依次循环，直到结束
public class ArrayDomo07 {
public static void main(String[] args) {
int[] array = {1,2,3,10,5,6,20,15,13};
int[] sort = sort(array); //调用完我们自己写的排序方法后，返回一个排序后的数组
System.out.print(Arrays.toString(sort));
}
public static int sort(int[] array){
//临时中间变量
int temp = 0;
//外层循环，判断我们这个要走几次
for(int i = 0; i < array.length - 1;i++){
boolean flag = false;
//内层循环，比较判断两个数字，如果后一个数大于前一个数，则交换位置
for(int j = 0;j < array.length - 1 - i;j++){
//if(array[j + 1] < array[j]) {}
if(array[j + 1] > array[j]){ //从大到下排序
//temp = array[j];
//array[j] = array[j + 1];
//array[j + 1] = temp;
temp = array[j + 1];
array[j + 1] = array[j];
array[j] = temp;
//优化
flag = true;
}
}
//优化
if(flag == false){
break;
}
}
return array;
}
}
浙公网安备 33010602011771号