Java入门知识梳理04

方法

方法是解决一个问题的有序组合

方法在程序中被创建在其他地方被引用

方法包含在类或对象中

一个方法只完成一个功能（原子性）

mian方法一定要简洁 一些公共的方法调用

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

方法体 具体的语句，定义该方法的功能

Return 返回值;

}

实参：实际跳用传递给他的参数 形参：用来定义作用

return还有终止方法的作用

方法的调用

public class Demo02 {
   public static void main(String[] args) {
   int max = max(10 , 10) ;
       System.out.println(max);
  }
   public static int max (int num1 ,int num2){
       if(num1 == num2){
           System.out.println("num1"  + "=" + "num2");
      }
      
       if(num1 > num2) {
           return num1;
      }else{
               return num2 ;
          }
      } 
  }

程序需要严谨 方法要对方法负责

值传递（java） 引用传递(需要了解)

方法的重载

一个类里有两个参数不同的同名方法

方法名必须相同 参数列表必须不同

命令行传参

cd ../ 返回上一级

可变参数 一个方法只能制定一个可变参数 而且要是方法中的最后一个参数

不定项参数

public class Demo4 {
   public static void main(String[] args) {
       printmax(10, 20, 30, 40, 50);
       printmax(new double[]{1, 2, 3, 4, 5});
  }
​
   public static void printmax(double... numbers) {
       if (numbers.length == 0) {
           System.out.println("No argument passed");
           return;
      }
       double result = numbers[0];
       for (int i = 0; i < numbers.length; i++) {
           if (numbers[i] > result) {
               result = numbers[i];
          }
      }
       System.out.println("max is :" + result);
​
​
  }

以上是不定项参数实例 实现未知项的最大值输出

递归

高频难点

递归就是 A方法调用A方法（自己）

可以大大减小代码量

public class Demo5 {
   public static void main(String[] args) {
       System.out.println(n(10));
       //实现阶乘计算并输出
  }
   public static int n(int f){
       if(f == 1 ){
           return 1 ;
​
      }else{
           return f * n(f -1) ;
      }
  }
}

以上代码借助递归的思想进行类阶乘的计算

边界条件：边界

前阶段 ：

返回阶段：

java都是使用栈机制的

递归头：什么时候不挑用自身的方法，如果没有头，将陷入死循环

递归体：什么时候需要挑用自身方法

作业：循环接受对象 加减乘除 利用循环+switch进行用户交互 传递需要操作的两个数 输出结果

数组

• 数组概述

• 数组的声明创建

• 数组的使用

• 多维数组

• Array类

数组是相同类型数据的有序集合

每一个数据称作一个数组元素 每个数组元素可以通过一个下标来访问它们

//变量的类型 变量的名称 = 变量的值

//数组类型 数组的名称 = 数组的值

public class ArrayDemo01 {
   public static void main(String[] args) {
       //声明数组
       int[] num ;
       //创建数组
       num = new int[10] ;
       //可以直接声明并创建
       int[] num1 = new int[10] ;
       num[0] = 1 ;
       num[1] = 2 ;
       num[2] = 3 ;
       num[3] = 4;
       num[4] = 5 ;
       num[5] = 6 ;
       num[6] = 7 ;
       num[7] = 8 ;
       num[8] = 9 ;
       num[9] = 10 ;
       int sum = 0 ;
       for (int i = 0; i < num.length; i++) {
           sum += num[i] ;
​
           System.out.println(sum);
      }
  }
}
​

获取数组的长度 .length();

画图软件推荐processon

内存分析

• 堆 存放new的对象和数组

• 栈

• 方法区

java.lang.ArrayIndexOutOfBoundsException

三种初始化

• 静态初始化 int[] a = {1,2,3,4,,5,6,7,8,9};(创建 + 赋值)

• 动态初始化 int[] b = new int[10] ; b[0] = 10 ;(包含默认初始化)

• 默认初始化

数组的四个基本特点

ArrayIndexOutOfBoundsException

public class ArrayDemo02 {
   public static void main(String[] args) {
       int[] a = {1 ,2 , 3, 4, 5} ;
       int[] num = new int[10] ;
       for (int i = 0; i <= a.length ; i++) {
           System.out.println(a[i]);
​
      }
       //System.out.println(a[]);
  }
}

以上实例运行会出现数据溢出的情况

数组的使用

for(int array arrays){

}

多维数组

int [][] array = {{1,2},{2,3},{3,4}}

二维数组是最常用的数组其他多

public class ArrayDemo03 {
   public static void main(String[] args) {
       int[][] array = {{1,2},{2,3},{3,4},{4,5}};
       for (int i = 0; i < array.length; i++) {
           for (int j = 0; j < array[i].length; j++) {
               System.out.println(array[i][j]);
​
          }
           
      }
  }
}

以上实例为二维数组的遍历 多维数组的思路相同

Arrays类

重复造轮子 工具类不要过度依赖

Arrays.sort(); //自动排序

冒泡排序

八大排序

是最出名的排序算法之一

• 比较数组中，两个相邻的元素，如果第一个比第二个大，我们就交换它们的位置

• 每比较一次，都会产生一个较大数，或者较小数

• 下一轮可以减少一次排序

• 一次循环，直到结束

交换两个数的值

import java.util.Arrays;
​
public class SuanDemo01 {
   public static void  main(String[] args) {
       int [] a = {1, 23, 3, 56, 7, 556, 78, 90, 102, 1999 } ;
       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 - 1; i++) {
           for (int j = 0; j < array.length - 1 - i; j++) {
               if(array[j] > array[j + 1]){
               temp = array[j + 1] ;
               array[j] = array[j + 1] ;
               array[j + 1] = temp ;
​
              }
​
          }
​
      }
       return array ;
  }
​
  }

以上是冒泡排序的程序实现

稀疏数组

将有效的数组存储起来 行 列 值

面向对象

属性 + 方法 就是一个类

物以类聚 ，分类的思维模式，

在整体上进行合理的分析 在细节上还是要面向过程

Object Oriented Programming OOP

以类的方式组织代码，以对象的组织数据

三大特性

• 封装

• 继承

• 多态 同一事物的不同形态

认知 ：先有的对象再有的类 对象是一个具体的事物 类是抽象的

代码 ：现有的类再有的对象

enter + alt

static 和类一起加载

实际参数与形式参数的类型要保持一致

规范：一个项目应该只存在一个main方法

类实例化之后会返回一个自己的对象

一个类即使什么都不写也会存在一个方法

使用new关键字本质就是在调用构造器

一旦定义了有参构造，无参一定要显示

Alt + insert

构造器

1. 和类名相同

2. 没有返回值

作用

1. new本质在调用构造方法

2. 初始化对象的值

注意点

1. 定义有参构造之后，如果像使用无参构造，显示的定义一个无参的构造

封装

高内聚 低耦合

private String name ;//属性私有化
private int id ;
private char sex ;
​
public String getname(){
 return this.name;
}
public void setName(String name){
 this.name = name ;
}

继承

Ctrl + h 快捷键

在java中所有的类都默认直接或间接继承Object