方法
什么是方法
System.out.println(),
调用系统中System类中的标准输出对象out中的println方法
Java方法是语句的集合，他们在一起执行一个功能
方法包含于类或者对象中
方法设计的原则：一个方法只完成一个功能。
public class Demo01 {
//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;
}
public class Demo01 {
public static void main(String[] args) {
test();
}
public static void test(){
for (int i=0 ; i<=1000 ; i++){
if(i%5==0){
System.out.print(i+"\t");
}
if (i%15==0){
//换行 这里可以输出空 或者 print("\n")
System.out.print("\n");
}
}
}
}
main方法时刻保持简洁干净
方法调用：对象名. 方法名（实参列表）
java支持两种调用方法的方式，根据方法是否返回值来选择。
当方法返回一个值的时候，方法调用通常被当作一个值。例如：
int larger = max （30，40）；
如果方法返回值是void，方法调用的一定是一条语句。
System.out.println("Hello,kuangshen!");
public class Demo02 {
public static void main(String[] args) {
int max = max(10,20);
System.out.println(max);
}
//比大小
public static int max (int num1,int num2){
int result = 0;
//设置result初始值
if (num1==num2){
System.out.println("相等");
return 0 ; //终止方法
}
if(num1>num2){
//对实参进行比较
result = num1;
}else {
result = num2;
}
return result;
}
}
20
方法重载
一个类拥有两个方法，并且拥有相同的名字，只是参数（参数类型）不同
1、方法名称必须相同
2、参数列表必须不同（个数不同，类型不同，或参数排列顺序不同）
3、方法返回的类型可相同也可以不相同
实现理论：方法名称相同，编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器会报错
public class Demo02 {
public static void main(String[] args) {
int max = max(10,20);
System.out.println(max);
}
public static int max (int num1,int num2){ //int类型
int result = 0;
if (num1==num2){
System.out.println("相等");
return 0 ;
}
if(num1>num2){
result = num1;
}else {
result = num2;
}
return result;
}
public static double max (double num1,double num2,double num3){
double result = 0;
if(num1==num2){
System.out.println("相等");
return 0 ;
}
if(num1>num2){
result = num1;
}
if (num1==num2){
result = num3;
}
else {
result = num2;
}
return result;
}
}
命令行传递参数
可变参数
在方声明中，在制定参数类型后加一个省略号...
一个方法中只能制定一个可变参数，它不需是方法中最后一个参数，任何普通的参数必须在它之前声明
递归
一个方法自己调用自己的方法叫递归调用，可以重复执行一段代码
递归结构包含两个部分：
递归头 什么时候不调用自身方法。如果没有头，将陷入死循环
递归体 什么时候需要调用自身方法
public class Demo05 {
public static void main(String[] args) {
int i = sum_recursion(1,3);
System.out.println(i);
}
//定义一个递归方法,实现求累加和
public static int sum_recursion(int start,int end){
//递归方法的出口，递归方法调用必须缩小范围
if(start==end){
return end;
}
//实现递归调用
return start + sum_recursion(start+1,end);
}
}
每次执行方法都会在JVM栈中开辟一块内存，用于存放执行方法所需要的数据，比如方法的局部变量，对象引用等，这块内存叫栈帧，JVM栈是JVM运行时内存的一个区域，JVM运行时内存还包括堆、方法区、程序计数器等区域
栈，一种数据结构，具有后进先出的特点
入栈（也叫压栈）出栈（也叫弹栈），执行方法就会压栈，所以递归不定义栈出口的时候就会栈溢出
public class Demo06 {
public static void main(String[] args) {
System.out.println(f(4));
}
public static int f (int n){
if (n==1){
return 1;
}else {
return n*f(n-1);
}
}
}
数组
声明与创建
1）首先需要声明数组变量，才能在程序中使用数组
数据类型[ ] 数组名
int[] nums;
2）使用new操作符来创建数组
nums = new int[];
public class ArrayDemo01 {
public static void main(String[] args) {
int[] nums; //声明一个数组
nums = new int[10]; //创建一个数组 ， 这里面可以存放10个int型的数字
//给数组元素赋值
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[0]);
//计算所有元素的和
int sum = 0;
for(int i = 0 ; i < nums.length ; i++){
sum = sum + nums[i];
}
System.out.println("总和为"+ sum);
}
}
三种初始化方式
//静态初始化
int[] a = {1,2,3,4,5, }
//动态初始化 :包含默认初始化
int nums[];
nums = new int[10];
数组的默认初始化 ，数组是引用类型，他的元素相当于类的实例变量，因此数组已经分配空间，其中每个元素也被按照实例变量的同样方式被隐式初始化
数组的四个基本特点
1、数组是不可变的，如果相添加元素必须重新声明创建
2、其元素必须是相同类型，不允许出现不同类型，是int就都是int
3、数组中的元素可以是任意数据类型，可以是基本类型也可以是引用类型
4、数组变量属于引用引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量，数组本身就是对象，java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。
数组的使用
普通for循环 取出数组最大的值
package com.uchiha.array;
public class ArrayDemo03 {
public static void main(String[] args) {
//声明数组
int[] nums ;
//创建数组
nums = new int[10];
nums[0] =5;
nums[1] =4;
nums[2] =2;
nums[3] =5;
nums[4] =6;
nums[5] =8;
nums[6] =4;
nums[7] =1;
nums[8] =9;
nums[9] =6;
//查找最大元素
//循环出nums的每个值
//定义初始的max用来接收数组的值
int max = nums[0];
//使用循环，从数组中的第一个数开始遍历出数组的每个脚标
for (int i = 0; i < nums.length; i++) {
//条件判断，如果数组中的数字大于上一次循环中数组赋给max的值那么则将此时数组的值赋值给max
if(nums[i]>max){
max = nums[i];
}
}
System.out.println(max);
}
}
增强for循环 ：foreach 使用：array.for 没有下标
数组作方法入参 打印数组
public class ArrayDemo06 {
public static void main(String[] args) {
int[] nums = {1,2,3,4,5,6}; //创建数组 静态初始化
print(nums);
}
public static void print(int[] arrays){
for (int i = 0; i < arrays.length; i++) { //使用for循环，循环出arrays的下标，下标打印数组
System.out.print(arrays[i]);
}
}
}
数组作返回值
public class ArrayDemo05 {
public static void main(String[] args) {
int[] arrays = {1,2,3,4,5};
int[] reverse = reverse(arrays);
PrintArray(reverse);
}
public static int[] reverse(int[] arrays){
int[] result ; //定义数组
result = new int[arrays.length]; //创建数组，数组的大小等于传入数组arrays的大小
//反转的操作
for (int i = 0 , j = result.length-1 ; i < arrays.length; i++,j--) {
result[j] = arrays[i]; //将数组arrays的第i个元素传递给数组result数组
}
return result;
}
//打印数组的方法
public static void PrintArray(int[] arrays){
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i]);
}
}
}
二维数组
public class ArrayDemo06 {
public static void main(String[] args) {
int[][] nums = {{1,2},{2,3},{3,4}};
print(nums);
}
//定义一个打印二维数组的方法
public static void print(int[][] nums){
for (int i = 0; i < nums.length; i++) {
for (int j = 0; j < nums[i].length; j++) {
System.out.println(nums[i][j]);
}
}
}
}
arrays类
如果我们要学习一个新的类，就进入这个类 command 进入
public class ArrayDemo07 {
public static void main(String[] args) {
int[] nums = {1,3,2,5,9,7}; //创建一个数组
System.out.println(Arrays.toString(nums)); //使用Arrays.toString 来打印数组
print(nums);
}
//自己编写一个方法来打印数组
public static void print(int[] arrays){
for (int i = 0; i < arrays.length; i++) { //
if(i == 0){
System.out.print("[" );
}if(i == arrays.length-1 ){
System.out.print(arrays[i] + "]");
}else
System.out.print(arrays[i]+", ");
}
}
}
冒泡排序
public class ArrayDemo08 {
public static void main(String[] args) {
int[] arrays = {2,1,3,9,6};
int[] sort = sort(arrays);
System.out.println(Arrays.toString(sort));
}
//冒泡排序 比较数组中两个相同的元素，如果第一个数比第二个数大，我们就交换他们的位置
//
public static int[] sort(int[] arrays){
for (int i = 0; i < arrays.length; i++) {
//判断循环需要走多少次 防止角标越界
for (int j = 0; j < arrays.length-1-i; j++) {
int temp = arrays[j];
if(arrays[j]>arrays[j+1]){
arrays[j]=arrays[j+1];
arrays[j+1] =temp;