使用IDEA进行学习

idea的常用快捷键

Alt+Enter 导入包 自动修正代码
Ctrl+Y 删除光标所在行
Ctrl+D 复制光标所在行
Ctrl+Alt+L 格式化代码
Ctrl+/ 单行注释，再按取消注释
Ctrl+Shift+/ 多行注释，再按取消注释

方法的三种调用格式

方法其实就是若干语句的功能集合。
方法好比是一个工厂。
蒙牛工厂 原料：奶牛、饲料、水
产出物：奶制品
钢铁工厂 原料：铁矿石、煤炭
产出物：钢铁建材

参数（原料）：就是进去方法的数据。
返回值（产出物）：就是从方法中的数据。

定义方法的完整格式：
修饰符 返回值类型 方法名称（参数类型 参数名称,…）{
方法体
return 返回值;
}
修饰符：现阶段的固定写法，public static
返回值类型：也就是方法最终产生的数据结果是什么类型
方法名称：方法的名字，规则跟变量一样，小驼峰
参数类型：进入方法的数据是什么类型
参数名称：进入方法的数据对应的变量名称
ps：参数如果有多个，使用逗号隔开
方法体：方法需要做
方法体：方法需要做的事情，若干代码
return：两个作用，第一个是停止当前方法，第二将后面的返回值还给调用处
返回值：也就是方法执行后最终产生的数据结果
注意：return后面的返回值，必须和方法名称前面的“返回值类型”，保持对应。

定义一个两个int数字相加的方法。三要素：
返回值类型 int
方法名称：sum
参数列表：int a,int b
方法的三种调用格式。
1.单独调用：方法名称（参数）；
2.打印调用：System.out.println(方法名称（参数）);
3.赋值调用:数据类型 变量名称 =方法名称（参数）；

注意：此前学习的方法，返回值类型固定写为void，这种方法只能使用单独调用，不能进行打印调用和赋值调用。

public class MethodDefine {
    public static void main(String[] args) {
        //单独调用
        sum(10, 20);
        System.out.println("==========");

//打印调用
        System.out.println(sum(10, 20));
        System.out.println("==========");

        //赋值调用
        int num=sum(20,20);
        System.out.println("变量的结果"+num);

    }

    public static int sum(int a, int b) {
//            System.out.println("方法执行了？");
        int result = a + b;
        return result;

    }
}

对比有参数和无参数

有参数：小括号当中有内容，当一个方法需要一些数据条件，才能完成任务的时候，就是有参数。
例如两个数字相加，必须知道两个数字各是多少，才能相加。

无参数：小括号当中留空，一个方法不需要任何数据条件，自己就能独立完成任务，就是无参数。
例如定义一个方法，打印固定10次HelloWorld。

public class MethodParam {
    public static void main(String[] args) {
method1(10,20);
System.out.println("==========");
method2();
    }
    //两个数字相乘，做乘法，必须知道两个数字各自是多少，否则无法进行计算。
    //有参数
    public static void method1(int a,int b){
        int result=a * b;
        System.out.println("结果是:"+result);
    }
    //打印输出固定10次文本字符串
    public static void method2(){
        for (int i = 0; i < 10; i++) {
            System.out.println("Hello,World"+i);
        }
    }
}

对比有返回值和无返回值

题目要求：定义一个方法，用来【求出】两个数字之和。（你帮我算，算了把结果告诉我）
题目变形：定义一个方法，用来【打印】两个数字之和。（你来计算，算完之后你自己负责显示结果，不告诉我）

注意事项：
对于有返回值的方法，可以使用单独调用、打印调用或者赋值调用。
但是对于无返回值的方法，只能使用单独调用，不能使用打印调用或者赋值调用。

public class MethodReturn {
    public static void main(String[] args) {
//我是main方法，我来调用你
        //我调用你，你来帮我计算一下，算完之后，把结果告诉我的num变量。
        int num=getSum(10,20);
        System.out.println("返回值是："+num);
        System.out.println("==========");
        printSum(100,200);
    }
    //我是一个方法，我负责两个数字相加。
    //我有返回值int，谁调用我，我就把计算结果告诉谁
    public static int getSum(int a, int b){
        int result=a + b;
        return result;
    }
    //我是一个方法，我负责两个数字相加
    //我没有返回值，我不会把结果告诉谁
    public static void printSum(int a,int b){
int result =a+b;
        System.out.println("结果是："+result);
    }
}

方法练习题

1比较两个数字是否相同

题目要求：
定义一个方法，用来判断两个数字是否相同。

public class MethodSame {
    public static void main(String[] args) {
        System.out.println(isSame(10,20));//false
        System.out.println(isSame(20,20));//true
    }
    /*
    三要素：
    返回值类型：boolean
    方法名称：isSame
    参数列表：int a, int b
     */
    public static boolean isSame(int a,int b){
    /*boolean same;
    if (a==b){
        same=true;
    }else {
        same= false;
    }*/
       // boolean same = a == b ? true : false;
       //boolean same = a == b;
    //return same;
        return a == b;
    }
}

求出1-100的和值

题目要求：
定义一个方法，用来求出1-100之间所有数字的和值

public class MethodSum {
    public static void main(String[] args) {
System.out.println("结果是："+getSum());
    }
    /*
    三要素：
    返回值：有返回值，计算结果是一个int数字
    方法名称：getSum
    参数列表：数据范围已经确定，是固定的，所以不需要告诉我任何条件，不需要参数
     */
    public static int getSum(){
        int sum =0;
        for (int i = 1; i <=100; i++) {
            sum += i;
        }
        return sum;
    }
}

打印指定次数的HelloWorld

题目要求：
定义一个方法，用来打印指定次数的HelloWorld

public class MethodPrint {
    public static void main(String[] args) {
printCount(10);
    }

    /*
    三要素：
    返回值类型：只是进行一大堆打印操作而已，没有计算，也没有结果要告诉调用出
    方法名称：printCount
    参数列表：到底要打印多少次？必须告诉我，否则我不知道，没办法打印。次数：int

     */
    public  static void printCount(int num){
        for (int i = 0; i < num; i++) {
            System.out.println("HelloWorld"+(i+1));
        }

    }
}

方法的注意事项

使用方法的时候，注意事项：
1，方法应该定义在类当中，但是不能在方法当中再定义方法，不能嵌套。
2.方法定义的前后顺序无所谓。
3.方法定义之后不会执行，如果希望执行，一定要调用：单独调用、打印调用、赋值调用。
4.如果方法有返回值，那么必须写上”return 返回值;“，不能没有。
5.return后面的返回值数据，必须和方法的返回值类型，对应起来。
6.对于一个void没有返回值的方法，不能写return后面的返回值，只能写return自己。
7.对于方法当中最后一行的return可以省略不写。
8.一个方法当中可以有多个return语句，但是必须保证同时只有一个会被执行到,两个return不能连写。

public class MethodNotice {
    public static int method1(){
        return  10;
    }
    public static void method2(){
       // return 10;//这是错误的写法!方法没有返回值，return后面就不能写返回值。
   return;//没有返回值，只是结束方法的执行而已。

    }
    public  static void method3(){
        System.out.println("AAA");
        System.out.println("BBB");
      //  return;//最后一行的return可以省略不写。
    }
    public static int getMax(int a,int b){
     /*   int max;
        if (a>b){
            max=a;
        }else {
            max=b;
        }
        return max;*/
        if (a>b){
            return a;
        }else {
            return b;
        }
    }
}

方法重载的基本使用

对于功能类似的方法来说，因为参数列表不一样，却需要记住那么多不同的方法名称，太麻烦。

方法的重载（Overload）：多个方法的名称一样，但是参数列表不一样。
好处：只需要记住唯一一个方法名称，就可以实现类似的多个功能。

public class MethodOverload {
    public static void main(String[] args) {
       /* System.out.println(sumTow(10,20));//30
        System.out.println(sumThree(10,20,30));//60
        System.out.println(sumFour(10,20,30,40));//100*/
        System.out.println(sum(10,20));
        System.out.println(sum(10,20,30));
        System.out.println(sum(10,20,30,40));
       // System.out.println(sum(10,20,30,40,50));//找不到任何方法来匹配，所以报错
    }
    public static int sum(int a, int b){
        System.out.println("有两个参数的方法执行！");
        return a+b;
    }
    public static  int sum(int a,int b,int c){
        System.out.println("有三个参数的方法执行！");
        return a+b+c;
    }
    public static  int sum(int a,int b,int c,int d){
        System.out.println("有四个参数的方法执行！");
        return a+b+c+d;
    }
}

方法重载的注意事项

方法重载与下列因数相关：
1.参数个数不同
2.参数类型不同
3.参数的多类型顺序不同

方法重载与下列因素无关：
1.与参数的名称无关
2.与方法的返回值类型无关

public class MethodOverload {
    public static void main(String[] args) {
       /* System.out.println(sumTow(10,20));//30
        System.out.println(sumThree(10,20,30));//60
        System.out.println(sumFour(10,20,30,40));//100*/
        System.out.println(sum(10,20));
        System.out.println(sum(10,20,30));
        System.out.println(sum(10,20,30,40));
       // System.out.println(sum(10,20,30,40,50));//找不到任何方法来匹配，所以报错
    }
    public  static  int sum(int a,double b){
return (int)(a+b);
    }
    public  static  int sum(double a,int b){
        return (int)(a+b);
    }
    public static int sum(int a, int b){
        System.out.println("有两个参数的方法执行！");
        return a+b;
    }
    //错误写法！与方法的返回值类型无关
   /* public static double sum(int a, int b){

        return a+b+0.0;
    }*/
    //错误写法！与参数的名称无关
    /*public static int sum(int x, int y){

        return x+y;
    }*/
    public static int sum(double a,double b){
        return (int)(a+b);
    }
    public static  int sum(int a,int b,int c){
        System.out.println("有三个参数的方法执行！");
        return a+b+c;
    }
    public static  int sum(int a,int b,int c,int d){
        System.out.println("有四个参数的方法执行！");
        return a+b+c+d;
    }
}

重载练习

1四种不同参数类型的方法

题目要求：
比较两个数据是否相等。
参数类型分别为两个byte类型，两个short类型，两个int类型，两个long类型，并在main方法中进行测试。

public class MethodOverloadSame {
    public static void main(String[] args) {
byte a=10;
byte b=20;
        System.out.println(isSame(a,b));
        System.out.println(isSame((short) 20,(short) 20));
        System.out.println(isSame(11,12));
        System.out.println(isSame(10L,20L));
    }
    public  static boolean isSame(byte a,byte b){
        System.out.println("两个byte参数的方法执行");
        boolean same;
        if (a==b){
            same=true;
        }else {
            same=false;
        }
        return same;
    }
        public  static boolean isSame(short a,short b){
            System.out.println("两个short参数的方法执行");
        boolean same = a ==b ? true : false;
        return same;

        }
        public static boolean isSame(int a,int b){
            System.out.println("两个int参数的方法执行");
        return a==b;
        }
        public static boolean isSame(long a,long b){
            System.out.println("两个long参数的方法执行");
        if (a==b){
            return  true;
        }else {
            return false;
        }
        }
    }

2判断方法的正确重载

1 public static void open(){}//正确重载
2 public static void open(int a){}//正确重载
3 static void open(int a, int b){}//代码错误：和第8行冲突
4 public static void open(double a, int b){}//正确重载
5 public static void open(int a, int b){}//代码错误：和第6行冲突
6 public void open(int i,double d){}//代码错误:和第5行冲突
7 public static void OPEN(){}//代码正确不会报错，但是并不是有效重载
8 public static void open(int i,int j){}代码错误：和第3行冲突

3实现重载的println方法

byte short int long float double char boolean
String
在调用输出语句的时候，println方法其实就是进行了多种数据类型的重载形式。

public class OverloadPrint {
    public static void main(String[] args) {
        myPrint(100);//int
        myPrint("Hello");
    }
    public static void myPrint(byte num){
        System.out.println(num);
    }
    public static void myPrint(short num){
        System.out.println(num);
    }
    public static void myPrint(int num){
        System.out.println(num);

    }
    public static void myPrint(long num){
        System.out.println(num);
    }
    public static void myPrint(float num){
        System.out.println(num);
    }
    public static void myPrint(double num){
        System.out.println(num);
    }
    public static void myPrint(char zifu){
        System.out.println(zifu);
    }
    public static void myPrint(boolean is){
        System.out.println(is);
    }
    public static void myPrint(String str){
        System.out.println(str);
    }
}

数组的概念

数组的概念：
是一种容器，可以同时存放多个数据值。
数组的特点：
1.数组是一种引用数据类型
2.数组当中的多个数据，类型必须统一
3.数组的长度在程序运行期间不可改变

数组的初始化：在内存当中创建一个数组，并且向其中赋予一些默认值。

两种常见的初始化方式
1.动态初始化（指定长度）
2.静态初始化（指定内容）

public class Array {
    public static void main(String[] args) {
        int score1=100;
        int score2=99;
        int score3=90;
        System.out.println(score3);//90
        score3=100;
        System.out.println(score3);//100
    }
}

数组的定义格式一：动态初始化

动态初始化数组的格式：
数据类型[ ] 数组名称 = new 数据类型[数组长度];

解析含义：
左侧数据类型：也就是数组当中保存的数据，全都是统一的什么类型
左侧的中括号:代表我是一个数组
左侧数组名称：给数组取一个名字
右侧的new：代表创建数组的动作
右侧数据类型:必须和左边的数据类型保持一致
右侧中括号的长度：也就是数组当中，到底可以保存多少个数据，是一个int数字。

public class Array {
    public static void main(String[] args) {
      //创建一个数组，里面可以存放300个int数据
    // 格式：数据类型[] 数组名称 = new 数据类型[数组长度];
            int[] arrayA= new int[300];
            //创建一个数组，能存放10个double类型的数据
        double[] arrayB=new double[10];
        //创建一个数组，能存放5个字符串
        String[] arrayC=new String[5];
    }
}

数组的定义格式二：静态初始化

动态初始化（指定长度）：在创建数组的时候，直接指定数组当中的数据元素个数。
静态初始化（指定内容）：在创建数组的时候，不直接指定数据个数多少，而是直接将具体的数据内容进行指定。
静态初始化基本格式：
数据类型[ ] 数组名称 =new 数据类型[ ] {元素1，元素2，…}；
注意事项：
虽然静态初始化没有直接告诉长度，但是大括号里面的元素具体内容，也可以自动推算出来长度。

public class Array {
    public static void main(String[] args) {
        //直接创建一个数组，里面装的全是int数字，具体为：5、15、20
        int [] arrayA =new int[]{5,15,25};

        //创建一个数组，用来装字符串：”Hello“、”World“、”Java“
        String [] arrayB=new String[]{"Hello","World","Java"};
        
    }
}

数组的定义格式三：省略的静态初始化

使用静态初始化数组的时候，格式还可以省略一下。

标准格式：
数据类型[ ] 数组名称 =new 数据类型[ ] {元素1，元素2，…}；

省略格式：
数据类型[ ] 数组名称 = {元素1，元素2，…}；

注意事项：
1.静态初始化没有直接指定长度，但是仍然会自动推算得到长度。
2.静态初始化标准格式可以拆分成为两个步骤。
3.动态初始化也可以拆分成为两个步骤。
4.静态初始化一旦使用省略格式，就不能拆分成为两个步骤了。

使用建议：
如果不确定数组当中的具体内容，用动态初始化；否则，已经确定了具体的内容，用静态初始化。

public class ArrayOne {
    public static void main(String[] args) {
//省略格式的静态初始化
        int[] arrayA={10,20,30};
        //静态初始化的标准格式，可以拆分成为两个步骤
        int[] arrayB;
        arrayB=new int[]{11,21,31};
        //动态初始化也可以拆分成为两个步骤。
        int[] arrayC;
        arrayC=new int[5];
    }
}

访问数组元素进行获取

直接打印数组名称，得到的是数组对应的：内存地址哈希值。
二进制：01
十进制：0123456789
十六进制：0123456789abcdef

访问数组元素的格式：数组名称[索引值]
索引值：就是一个int数字，代表数组当中元素的编号。
【注意】索引值从0开始，一直到”数组的长度-1“为止。

public class ArrayUse {
    public static void main(String[] args) {
       //静态初始化的省略格式
        int [] array={10,20,30};
//直接打印数组当中的元素
        System.out.println(array);//[I@723279cf
        System.out.println(array[0]);//10
        System.out.println(array[1]);//20
        System.out.println(array[2]);//30
//也可以将数组当中的某一个单个元素，赋值交给变量。
        int num =array[1];
        System.out.println(num);//20
    }
}

访问数组元素进行赋值

使用动态初始化数组的时候，其中的元素将会自动拥有一个默认值。规则如下：
如果是整数类型，那么默认为0；
如果是浮点类型，那么默认为0.0；
如果是字符类型，那么默认为’\u0000’；
如果是布尔类型，那么默认为false；
如果是应用类型，那么默认为null。

注意事项：
静态初始化其实也有默认值的过程，只不过系统自动马上将默认值替换成为了大括号当中的具体数值。

public class ArrayUseTow {
    public static void main(String[] args) {
        //动态初始化一个数组
        int[] array=new int[3];
        System.out.println(array);//内存地址值
        System.out.println(array[0]);//0
        System.out.println(array[1]);//0
        System.out.println(array[2]);//0
        System.out.println("===========");
        //将数据123赋值交给数组array当中的1号元素。
        array[1]= 123;
        System.out.println(array[0]);//0
        System.out.println(array[1]);//123
        System.out.println(array[2]);//0


    }
}

java中的内存划分

5个部分
1.栈（Stack）：存放的都是方法中的局部变量。 方法的运行一定要在栈当中。
局部变量：方法的参数，或者是方法{ }内部的变量
作用域：一旦超出作用域，立刻从栈内存当中消失。
2.堆（Heap）：凡是new出来的东西，都在堆当中。
堆内存里面的东西都有一个地址值：16进制
堆内存里面的数据，都有默认值。规则：
如果是整数类型，那么默认为0；
如果是浮点类型，那么默认为0.0；
如果是字符类型，那么默认为’\u0000’；
如果是布尔类型，那么默认为false；
如果是应用类型，那么默认为null。
3.方法区（Method Area）：存储.class相关信息，包含方法的信息。
4.本地方法栈（Nativa Method Stack）：与挫折系统相关。
5.寄存器（pc Register）：与CPU相关。

一个数组的内存图

两个数组的内存图

两个引用指向同一个数组的内存图

常见问题 ： 空指针异常

所有的引用类型变量，都可以赋值为一个NULL值。但是代表其中什么都没有。
数组必须进行new 初始化 才能使用其中的元素。
如果只是赋值了一个new，就没有进行new创建，
那么将会发生：
空指针异常 NullPointerException

原因：忘了new
解决：补上new

public class ArrayNull {

    public static void main(String[] args) {
        int [] array=null;
       //array =new int[3];
        System.out.println(array[0]);

    }
}

获取数组的长度

如何获取数组的长度，格式：
数组名称.length

这将会得到一个int数字，代表数组的长度。

数组一旦创建，程序运行期间，长度不可改变。

public class ArrayLength {
    public static void main(String[] args) {
        int [] arrayA =new int[3];
            int[] arrayB ={10,20,30,2,3,4,45,10};
            int len =arrayB.length;
        System.out.println("arrayB数组的长度是："+len);
        System.out.println("=========");
        int []arrayC = new int[3];
        System.out.println(arrayC.length);//3
        arrayC =new int[5];
        System.out.println(arrayC.length);//5

    }
}

数组的遍历输出

遍历数组，说的就是对数组当中的每一个元素进行逐一、挨个儿处理。默认的处理方式就是打印输出。

public class ArrayBl {
    public static void main(String[] args) {
        int[] array ={15,25,30,40,50};

        //首先使用原始方式
        System.out.println(array[0]);
        System.out.println(array[1]);
        System.out.println(array[2]);
        System.out.println(array[3]);
        System.out.println(array[4]);
        System.out.println("===========");

        //使用循环，次数其实就是数组的长度
        for(int i=0;i<array.length;i++){
            System.out.println(array[i]);
        }

    }
}

求出数组中的最值

最大值

public class ArrayMax {
    public static void main(String[] args) {
        
    
    int[] array={5,15,30,20,10000};

    int max =array[0];
        for (int i = 1; i < array.length; i++) {
            //如果当前元素，必max更大；则换
            if (array[i]>max){
                max=array[i];

            }
            
        }//谁最后最大，就能在max当中留下
        System.out.println("最大值"+max);
    }
}

最小值

public class ArrayMin {
    public static void main(String[] args) {
        
    
    int[] array={5,15,30,20,-20,10000};

    int min =array[0];
        for (int i = 1; i < array.length; i++) {
            //如果当前元素，必min更小；则换
            if (array[i]<min){
                min=array[i];

            }
            
        }//谁最后最大，就能在max当中留下
        System.out.println("最小值"+min);
    }
}

数组元素反转

数组元素的反转：
本来的样子:[1,2,3,4]
之后的样子:[4,3,2,1]

要求不能使用新数组，就用原来的唯一一个数组。

1.数组元素反转，其实就是【对称位置】的元素交换。

2.通常遍历数组用的是一个索引：
int i =0;
现在表示对称位置需要两个索引：
int min=0;
int max=array.length-1;

3.如何交换两个变量的值？
int a=10;
int b=20;
如果是两个水杯，都是满的，如何交换？借助第三个空杯子
int temp =a;
a=b;
b=temp;
用【第三个变量】倒手。

4.什么时候停止交换？
（1）min == max
（2）min>max
什么时候应该交换？
min<max

public class ArrayReverse {
    public static void main(String[] args) {
        int [] array ={10,20,8,7,11,89};
        //遍历打印数组本来的样子
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
        System.out.println("========");
/*
初始化语句：int min=0,max=array.length-1
条件判断：min <max
步进表达式：min++,max--
循环体：用第三个变量倒手
 */
        for (int min=0,max=array.length-1;min <max;min++,max--){
            int temp=array[min];
            array[min]=array[max];
            array[max]=temp;

        }
//再次打印输出
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

数组作为方法参数——传递地址

数组可以作为方法的参数。
当调用方法的时候，向方法的小括号进行传参，传递进去的其实是数组的地址值

public class ArrayParam {
    public static void main(String[] args) {
        int[] array={10,20,30,40,50};
        System.out.println(array);//地址值
printArray(array);//传递进去的就是array当中保存的地址值
        System.out.println("aaa");
        printArray(array);
        System.out.println("bbb");

    }
    /*
    三要素
    返回值类型：只是进行打印而已，不需要计算,也没有结果，用void
    方法名称：printArray
    参数列表：必须给我数组，我才能打印其中的元素。 int[] array

     */



    public  static void printArray(int[] array){
        System.out.println("printArray方法收到的参数是：");
        System.out.println(array);//地址值
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }

    }
}

数组作为方法返回值——返回地址

一个方法可以有0、1、多个参数；但是只能由0或者1个返回值，不能多个返回值。
如果希望一个方法当中产生了多个结果数据进行返回，怎么办？
解决方案：使用一个数组作为返回值类型即可。

任何数据类型都能作为方法的参数类型，或者返回值类型。

数组作为方法的参数，传递进去的其实是数组的地址值。
数组作为方法的返回值，其实返回的也是数组的地址值。

public class ArrayReturn {
    public static void main(String[] args) {
int[] result=calculate(10,20,30);
        System.out.println("总和："+result[0]);
        System.out.println("平均数："+result[1]);
    }
    public static int[]  calculate( int a,int b,int c){
        int sum=a+b+c;//总和
        int avg=sum/3;//平均数
        //两个结果都希望进行返回
        //需要一个数组,数组可以保存多个结果
        /*int [] array=new int[2];
        array[0]=sum;
        array[1]=avg;*/
        int[] array={sum,avg};
        return array;
    }
}