Java学习【代码3】

day3.edu_01
有明确返回值的方法调用：

A:单独调用
    没有意义
B:输出调用
    不是特别好,因为我们可能需要对结果进行进一步的操作。
C:赋值调用
    推荐方案

需求：定义一个两个数求和的方法

 修饰符：public static
 返回值类型：int 
 方法名：add
 参数列表：int a,int b
 方法体：{
    int c = a+ b;
    return c;
  }
  注意：定义一个方法一定要做到两个明确
 1.方法的参数类型和参数个数
 2.方法的返回值类型

package com.edu_01;
public class FunctionDemo2 {
    public static void main(String[] args) {
        //方法的调用一定是在main方法中被调用，因为main方法是一个程序的入口
        //A:单独调用，没有太大的意义
        //方法调用一定是传递的实际参数
        //add(10, 20);

        //B:输出调用
        //System.out.println(add(10, 20));

        //C:赋值调用,方便我们后面对这个变量的进一步操作
        //注意：方法的调用需要遵循：
        //              1.要啥类型的参数传递啥类型的参数
        //              2.返回什么类型的值，就使用什么类型的变量接受     int d = add(10, 20);
        System.out.println(d);
    }

    //方法与方法之间是平行关系，定义一个方法必须是在类中其他方法外

    public static int add(int a,int b){
        int c = a+ b;
        return c;
    }   
}

day3.edu_02
需求：求两个数据和的功能。
返回值:有，int
参数列表:int a,int b

package com.edu_01;
public class FunctionDemo3 {
    public static void main(String[] args) {
        System.out.println(add(10, 20));
    }

    public static int add(int a,int b){
        return a+b;
    }
}

day3.edu_03
需求：写一个功能实现返回两个数的较大值。
要求:数据来自于键盘录入。

做到两个明确：
返回值
    结果的数据类型int
参数
    参数的个数2，以及类型int

package com.edu_01;

import java.util.Scanner;

public class FunctionDemo4 {
    public static void main(String[] args) {
        //创建键盘录入对象并导包
        Scanner sc = new Scanner(System.in);

        //获取键盘录入数据
        System.out.println("请输入第一个数据");
        int a = sc.nextInt();
        System.out.println("请输入第二个数据");
        int b = sc.nextInt();

        //调用求最大值的方法
        int max = getMax(a, b);
        System.out.println(max);
    }
    public static int getMax(int a,int b){
        int c = a>b?a:b;
        return c;
    }
}

day3.edu_04
写一个功能实现比较两个数据是否相等。
要求，数据来自于键盘录入。

做到两个明确：
    返回值
        结果的数据类型:布尔类型
    参数
        参数的个数2，以及类型int

package com.edu_01;

import java.util.Scanner;

public class FunctionDemo5 {
    public static void main(String[] args) {
        //创建键盘录入对象并导包
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入第一个数据");
        int a = sc.nextInt();
        System.out.println("请输入第二个数据");
        int b = sc.nextInt();

        //调用方法进行判断
        System.out.println(isEquals(a, b));

    }

    public static boolean isEquals(int a,int b){
//      boolean flag = a==b;
//      return flag;
        return a==b;
    }
}

day3.edu_05
需求1：请在控制台输出4行5列的星形。
需求2：请在控制台输出6行7列的星形。
需求3：请在控制台输出8行9列的星形。
（最终封装成方法进行调用）

package com.edu_01;
public class FunctionDemo6 {
    public static void main(String[] args) {
        //需求1：请在控制台输出4行5列的星形。
        /**
         * 这里是for循环的嵌套，
         * 外层for循环控制行，
         * 内层for循环控制列，
         * 外层走一次，内层走一轮
         */
        /*for (int i = 0; i < 4; i++) {
            for(int j = 0;j<5;j++){
                System.out.print("*");
            }
            //添加一个换行符
            System.out.println();
        }*/


        //需求2：请在控制台输出6行7列的星形。
        /*for (int i = 0; i < 6; i++) {
            for (int j = 0; j < 7; j++) {
                System.out.print("*");
            }
            System.out.println();
        }*/


        //需求3：请在控制台输出8行9列的星形。
        /*for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 9; j++) {
                System.out.print("*");
            }
            System.out.println();
        }*/

        //printXing(10, 8);
        printXing(5, 6);
    }


    /**
     * 封装打印成星星的方法
     * 分析：
     * 参数列表：2，int
     * 返回值：无
     */

    public static void printXing(int row,int col){
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

day3.edu_06
需求：键盘录入三个数据，返回三个数中的最大值（写成一个方法可以直接调用并且返回值）

package com.edu_01;

public class FunctionDemo7 {
    public static void main(String[] args) {
        System.out.println(getMax(10, 5, 8));
    }

    public static int getMax(int a,int b,int c){
        int max ;
        if (a>b) {
            //a大
            if (a>c) {
                //a最大
                max = a;
            }else {
                //c最大
                max = c;
            }
        }else {
            //b大
            if (b>c) {
                //b
                max = b;
            }else {
                //c
                max = c;
            }
        }
        return max; 
    }
}

day3.edu_07
方法重载：
前提：在同一个类中
允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
需求1：求两个数据和
需求2：求三个数据和
需求3：求四个数据和

package com.edu_02;
public class FunctionOverload {
    public static void main(String[] args) {
        //调用下面的两个参数的加法
        System.out.println(add(10, 20));

        //调用下面的三个参数的加法
        System.out.println(add(10, 20, 30));
        }
    //需求1：求两个数据和
    public static int add(int a,int b){
        System.out.println("两个参数的被调用");
        return a+b;
    }

    //需求2：求三个数据和
    public static int add(int a,int b,int c){
        System.out.println("三个参数的被调用");
        return a+b+c;
    }

    //需求3：求四个数据和
    public static String add(String a,String b){
        System.out.println("四个参数的被调用");
        return a+b;
    }
}

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

package com.edu_02;

public class FunctionOverload2 {
    public static void main(String[] args) {
        //定义两个int类型的数据，进行比较
        int a = 10;
        int b = 20;
        System.out.println(isEquals(a, b));

    }

    public static boolean isEquals(byte a,byte b){
        System.out.println("比较两个byte类型的数据是否相等");
        return a==b;
    }

    public static boolean isEquals(short a,short b){
        System.out.println("比较两个short类型的数据是否相等");
        return a==b;
    }


    public static boolean isEquals(int a,int b){
        System.out.println("比较两个int类型的数据是否相等");
        return a==b;
    }

    public static boolean isEquals(long a,long b){
        System.out.println("比较两个long类型的数据是否相等");
        return a==b;
    }
}

day3.edu_09
如何为数组进行初始化:
动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。
动态初始化：
初始化时只指定数组长度，由系统为数组分配初始值。
格式：
数据类型[] 数组名 = new 数据类型[数组长度];
数组长度其实就是数组中元素的个数。

package com.edu_03;
public class ArrayDemo2 {
    public static void main(String[] args) {
        //创建一个int类型的数组，这个数组的长度为3
        //动态的初始化了一个数组
        int[] arr = new int[3];
        System.out.println(arr);//[I@33abb81e,这是一个地址值
        System.out.println(arr[0]);//0
        System.out.println(arr[1]);//0
        System.out.println(arr[2]);//0

        //再给每一个元素进行赋值
        arr[0] = 10;
        arr[1] = 20;
        arr[2] = 30;
        System.out.println(arr);//[I@33abb81e,这是一个地址值
        System.out.println(arr[0]);//10
        System.out.println(arr[1]);//20
        System.out.println(arr[2]);//30 
    }
}

day3.edu_10
需求：定义一个数组，分别输出数组名及元素。然后分别给数组中的元素赋值，分别再次输出数组名及元素。

package com.edu_03;

public class ArrayDemo3 {
    public static void main(String[] args) {
        int[] arr = new int[3];
        System.out.println(arr);//[I@33abb81e
        System.out.println(arr[0]);//0
        System.out.println(arr[1]);//0
        System.out.println(arr[2]);//0

        System.out.println("-----------");
        arr[1] = 30;
        arr[2] = 40;
        System.out.println(arr);//地址值
        System.out.println(arr[0]);//0
        System.out.println(arr[1]);//30
        System.out.println(arr[2]);//40     
    }
}

day3.edu_11
需求：定义两个数组，先定义一个数组，赋值，输出。
然后定义第二个数组的时候把第一个数组的地址赋值给第二个数组。
然后给第二个数组赋值，再次输出两个数组的名及元素。

package com.edu_03;

public class ArrayDemo4 {
    public static void main(String[] args) {
        int[] arr = new int[3];
        arr[0] = 10;
        arr[1] = 20;
        arr[2] = 30;

        //输出数组中的元素
        System.out.println(arr[0]);//10
        System.out.println(arr[1]);//20
        System.out.println(arr[2]);//30

        System.out.println("-----------------");
        int[] arr2 = arr;
        arr2[1] = 300;
        arr2[2] = 200;

        System.out.println(arr[1]);//300
        System.out.println(arr[2]);//200    
    }
}

day3.edu_12
静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。
静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。
格式：
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
简化格式：
数据类型[] 数组名 = {元素1,元素2,…};

package com.edu_03;

public class ArrayDemo5 {
    public static void main(String[] args) {
        //使用静态初始化一个int数组（标准格式）
/*      int[] arr = new int[]{1,3,5,6};
        System.out.println(arr);//[I@33abb81e
        System.out.println(arr[0]);//1
        System.out.println(arr[1]);//3
        System.out.println(arr[2]);//5
        System.out.println(arr[3]);//6
*/      
        System.out.println("------------------");
        //使用静态初始化一个数组(简化格式)
        int[] arr2 = {10,30,20};
        System.out.println(arr2);//[I@7f39ebdb
        System.out.println(arr2[0]);//10
        System.out.println(arr2[1]);//30
        System.out.println(arr2[2]);//20    
    }
}

day3.edu_13
数组操作常见的两个小问题
A:
ArrayIndexOutOfBoundsException:数组索引越界异常
怎么产生的：
你访问了不存在的索引。
如何解决：
修改你的访问索引。
B:
NullPointerException:空指针异常
怎么产生的：
引用已经不再指向堆内存
如何解决：
一般来说，只要是引用类型的变量，我们在使用前，都要先判断是否为null。
如果不为null，才继续使用。

package com.edu_03;
public class ArrayDemo6 {
    public static void main(String[] args) {
        //静态初始化一个数组，使用简化格式
        int[] arr = {1,3,5,6};
        //取出数组中的每一个元素
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        System.out.println(arr[3]);
        //System.out.println(arr[4]);
        /**
         * java.lang.ArrayIndexOutOfBoundsException:数组索引越界异常
         * ，不能访问超过数组最大索引的元素，如果访问就会报出这个数组索引越界异常
         */

        //arr = null;
        /**
         * java.lang.NullPointerException:空指针异常，说白了此刻我的引用
         * 毫无指向
         */
        System.out.println(arr[1]);
    }
}

day3.edu_14
数组遍历:
依次输出数组中的每一个元素
数组遍历标准格式：
for(int x=0; x<数组名.length; x++) {
System.out.println(数组名[x]);
}
练习：
自己定义一个数组，并遍历。

package com.edu_03;
public class ArrayDemo7 {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = {1,3,5,6};

        //遍历
//      System.out.println(arr[0]);
//      System.out.println(arr[1]);
//      System.out.println(arr[2]);
//      System.out.println(arr[3]);

        //使用for循环改进数组遍历的方法
        //数组的长度，怎么获取,通过数组的length属性获取数组的长度
        //System.out.println(arr.length);
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+"  ");
        }
    }
}

day3.edu_15
需求：我们可能有很多个数组需要遍历，所以我们把遍历写成一个功能。

package com.edu_03;

public class ArrayDemo8 {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = {5,6,7,8};
        printArray(arr);
    }
    /**
     * 分析：
     * 参数列表：1，int[]
     * 返回值：无
     */
    public static void printArray(int[] arr){
        //拿到arr作何操作？？？
        for (int i= 0;i<arr.length;i++) {
            //打印数组中的每一个元素
            System.out.print(arr[i]+",");
        }
    }
}

day3.edu_16
数组获取最值(获取数组中的最大值最小值)

package com.edu_03;

public class ArrayDemo9 {
    public static void main(String[] args) {
        int[] arr = {5,7,9,10};

        //假设数组中的第一个元素就是最大值
        int max = arr[0];

        //for循环遍历数组，在for循环中进行比较判断
        for (int i = 0; i < arr.length; i++) {
            if (arr[i]>max) {
                max = arr[i];
            }
        }

        System.out.println(max);
    }
}

day3.edu_17

package com.edu_05;

public class Student {

    //成员变量:位于类中方法外
    String name;
    int age;

    //成员方法:没有static,方法与方法之间是平性关系
    public void eat(){
        System.out.println("学生爱吃米饭");
    }

    public void study(){
        System.out.println("吃饱了该学习了");
    }

    public void makePlane(){
        System.out.println("学生会制造飞机模型");
    }
}

package com.edu_05;
public class Test {
    public static void main(String[] args) {
        //创建一个学生对象
        //类名   对象名 = new 类名();
        Student s = new Student();

        //打印一下这个学生对象的姓名和年龄
        //System.out.println(s.name);//null
        //System.out.println(s.age);//0

        //给学生对象的姓名和年龄赋值
        s.name = "刘德华";
        s.age = 50;

        System.out.println(s.name);//刘德华
        System.out.println(s.age);//50

        //试用一下学生的成员方法
        s.eat();
        s.makePlane();
        s.study();
    }
}

day3.edu_18

package com.edu_06;

public class Phone {
    //成员变量
    String brand;
    int price;

    //成员方法
    public void call(String name){
        System.out.println(name+"正在给我打电话");
    }

    //玩游戏
    public void playGame(){
        System.out.println("手机可以玩游戏");
    }

}

package com.edu_06;

public class Test {
    public static void main(String[] args) {
        //创建手机对象
        Phone p = new Phone();

        //打印手机的品牌和价格
        System.out.println(p.brand);
        //null,因为brand是String类型，引用类型
        System.out.println(p.price);//0

        //给手机的成员变量赋值
        p.brand = "oppo";
        p.price = 2000;

        System.out.println(p.brand);
        System.out.println(p.price);

        //调用成员方法
        p.call("刘德华");
        p.playGame();
    }
}

day3.edu_19
如果一个文件中需要写多个类的话需要注意以下几点：
1.main方法所在的类名必须和文件名相同
2.类与类之间是平行关系

package com.edu_07;
public class PhoneTest {
    public static void main(String[] args) {
        //如何使用Phone这个类
        //创建对象使用里面的成员变量
        Phone p = new Phone();

        p.brand = "苹果";
        p.price = 5000;

        System.out.println(p.brand);
        System.out.println(p.price);

        //调用成员方法
        p.call();
        p.playGame();   
    }
}


//定义一个手机类
class Phone{
    //成员变量
    String brand;
    int price;

    //成员方法
    public void call(){
        System.out.println("刘德华给我打电话");
    }

    public void playGame(){
        System.out.println("郭德纲约我打游戏");
    }
}

day3.edu_20
成员变量和局部变量的区别:
A:在类中的位置不同
成员变量 类中方法外
局部变量 方法内或者方法声明上
B:在内存中的位置不同
成员变量 堆内存
局部变量 栈内存
C:生命周期不同
成员变量 随着对象的存在而存在，随着对象的消失而消失
局部变量 随着方法的调用而存在，随着方法的调用完毕而消失
D:初始化值
成员变量 有默认初始化值
局部变量 没有默认初始化值

package com.edu_08;
public class VariableDemo {

    int age;//成员变量，位于类中方法外

    public void add(int a, int b){//局部变量位于方法中或者方法上
        int c = a+b;
        System.out.println(a+b);
    }

    public void show(){
        int d;
        //d是一个局部变量，在此时他并没有被初始化，没有被初始化的变量不能使用
        //局部变量系统不会给一个默认的初始化值
        //System.out.println(d);
    }
}

day3.edu_21
匿名对象
匿名对象：就是没有名字的对象
是对象一种简写形式。
应用场景：
A:调用方法(对象调用方法仅仅一次的时候)
B:作为实际参数传递

package com.edu_09;

public class MyMath {

    //创建一个加法
    public int add(int a,int b){
        return a+b;
    }
}

day3.edu_22
匿名对象
匿名对象：就是没有名字的对象
是对象一种简写形式。

应用场景：
A:调用方法(对象调用方法仅仅一次的时候)
B:作为实际参数传递

package com.edu_09;

public class MyMath {

    //创建一个加法
    public int add(int a,int b){
        return a+b;
    }
}

package com.edu_09;
class Student{
    public void show(){
        System.out.println("student的show方法");
    }
}


class StudentDemo{
    public void method(Student s){//需要的实际参数一定是Student类的对象的的地址值
        s.show();
    }
}


public class StudentTest {
    public static void main(String[] args) {
/*      //我现在需要调用StudentDemo中的method()方法
        StudentDemo sd = new StudentDemo();
        //需要的实际参数一定是Student类的对象的的地址值
        Student s = new Student();
        sd.method(s);*/

        System.out.println("--------------------------");
        //想调用我现在需要调用StudentDemo中的method()方法
        //使用匿名对象调用方法,并传递参数
        new StudentDemo().method(new Student());    
    }
}

package com.edu_09;

public class Test {
    public static void main(String[] args) {
        //创建MyMath类的实力对象
        MyMath my = new MyMath();
        //调用里面的加法
        int sum = my.add(10, 20);
        System.out.println(sum);
    }
}