学习java的第三天

1. 方法，在其他语言中也可称为函数
    方法的语法如下：
    返回值类型  方法名  （参数） { 方法体 }

    public static int max(int a,int b){
        int max=a>b?a:b;
        return max;
        //return  用来返回数据
    }
    public int sum(int a,int b){
        int sum=a+b;
        return sum;
    }
    public static void printMaxA(int a,int b){
        //得到最大值
        //调用本类中已经定义的方法
        int result = max(a,b);
        //打印出最大值来
        System.out.println(result);
    }
    public static void sum(int a,int b){
    Systm.out.println("总和为:"+(a+b));
    }

上面第三个方法的返回值类型为void

若不需要返回值时返回值类型填写void，void中可以写return,但是不能return null

同时return表示方法结束，方法中return语句下面不可继续写代码

2.形参：形参是方法定义时，参数列表的参数名 

实参：实参是调用列表时，实际传入的参数

3.方法的重载

在同一个类中，方法名相同但是参数列表不同即为重载

参数列表的三个要素：

1参数类型不同

    public int method(int a){
        return 0;
    }
    public int method(byte a){
        return 0;
    }

2参数个数不同

    public int method(int a){
        return 0;
    }
    public int method(int a,int b){
        return 0;
    }

3参数的顺序不同（注意跟形参名称a,b无关）

    public int method(int a,byte b){
        return 0;
    }
    public int method(byte a,int b){
        return 0;
    }

4小实例：在方法中输出数组的最大值

    public static int max(int[] arr){
        int max=arr[0];
        for (int i=0;i<arr.length;i++){
            if (arr[i]>max){
                max=arr[i];
            }
        }
        return max;
    }

然后在main函数中调用max()方法，输出max的值

4.可变参数：不确定传入多少个参数时使用可变参数

可变参数的声明：  (int... a)表示不确定有几个int类型的参数

可变参数的使用 ： 当作数组使用

注意点： （1）一个方法中只能有一个可变参数 （2）可变参数必须放在参数列表的最后 （3）可变参数是数量可变，类型不可变 （4）调用可变参数方法可以使用数组代替(学JDBC的时候会讲) （5）可变参数可以不传

    public static int sum(int... a){
        int sum=0;
        for(int item:a){
            sum+=item;     //将每一个输入的对象item加到总和sum中
        }
        return sum;
    }
        //输出语句
        System.out.println(sum(1,1,2,2,3,3,4,4,5,5));
        //输出结果为30

5.方法的递归

递归：方法自己调用自己（不能一直调用自己，要有条件约束）

小实例：输出阶乘 !num

    public static int jiecheng(int num){
        if (num==1){
            return 1;
        }
        return num*jiecheng(num-1);
    }
        //输出语句
        int num=jiecheng(5);//给num赋值5，求5的阶乘
        System.out.println(num);//输出结果为120

6.排序算法

以冒泡排序为例:

    public static void maopao(int[] arr){
        for (int j=0;j<arr.length-1;j++){
            //内层循环完成一次就确定一个位置的值
            for (int i=0;i<arr.length-j-1;i++){//arr.length-j-1的原因是减少代码冗余
            //如果前面的元素大，就交换位置（两个元素交换值）
            //要考虑数组越界的可能性
                if (arr[i]>arr[i+1]){
                int temp=arr[i];
                arr[i]=arr[i+1];
                arr[i+1]=temp;
                }
            }
        }
    }
    public static void main(String[] args) {
        int[] arr={11,33,52,17,1,24};//定义并初始化数组
        maopao(arr);调用冒泡排序方法maopao
        System.out.println(Arrays.toString(arr));//数组数据处理完毕后输出
        //[1, 11, 17, 24, 33, 52]
    }

7.类的定义

先定义一个Staff类

public class Staff {
    //在类中定义属性（属性又叫做全局变量）
    String code;
    String sex;
    String name;
    double salary;
    
    //类的方法可以直接调用本类中的属性
    public void work(){
        System.out.println(name+"正在工作");
    }
}

在main函数中实例化对象：

实例化对象，就是开辟内存空间

public class TestStaff {
    public static void main(String[] args) {
        //实例化对象（即开辟内存空间）
        Staff staff = new Staff();
        //设置对象的属性   类中声明了哪些属性，对象中就有哪些属性
        staff.code="YG10001";
        staff.name="张三";
        staff.sex="男";
        staff.salary=10000;

        Staff staff1 = new Staff();
        staff1.code="YG10002";
        staff1.name="李四";
        staff1.sex="女";
        staff1.salary=10000;

        //调用对象的方法
        staff.work();    //张三在工作
        staff1.work();   //李四在工作
    }
}

构造方法:

构造方法用来对对象进行初始化

在Staff类下原本有一个默认为空的构造方法：

public Staff(){
    
}

在Staff类下写一个构造方法：

(1)局部变量 在方法体或者代码块中声明的变量 (2)全局变量 在类中定义的变量叫全局变量

在局部变量和全局变量重名的情况下，可以使用this关键字来标注全局变量:

this.name=name;

    public  Staff(String name){
        this.name=name;
    }

定义构造方法 （1）没有返回值类型 （2）构造方法的方法名和类名必须相同 （3）如果一个类没有定义任何的构造方法，系统会给一个默认的空的构造方法（4）类中一旦自定义了任意的构造方法，系统给定的默认构造方法就消失了

public class TestStaff {
    public static void main(String[] args) {
        Staff staff = new Staff("aaa");//在构造方法里传进参数String name
        staff.code="YG10001";
        staff.sex="男";
        staff.salary=10000;

        Staff staff1 = new Staff("bbb");
        staff1.code="YG10002";
        staff1.sex="女";
        staff1.salary=10000;

        //调用对象的方法
        staff.work();   //aaa在工作
        staff1.work();  //bbb在工作
    }
}

8.面向对象的三大特性：

封装     继承     多态

9.封装：隐藏类中的细节，不能让其他类随意的访问

通过四个权限访问修饰符达到封装的效果：public protected default private

public公共的   protected受保护的   default默认的（本包中访问）  private私有的(只能在本类中访问)

四个权限访问修饰符的范围：

10.继承：一个子类可以继承父类，子类就具有父类中定义好的属性和方法 （不是所有的属性和方法都能调用到（有访问权限才可以，public，protected，本包下出现的父类的default））

继承的好处：（1）代码重用  （2）继承是多态的基础

创建一个父类Plane：

class Plane{
    String code;//向上的父类访问不到   向下的子类和本包下的类可以访问到
    String color;
    public Plane(String color){
        this.color=color;
    }
    public Plane(String code, String color){
        this.code=code;
        this.color=color;
    }
    public Plane(){}
    public void fly(){
        System.out.println("飞机");
    }
}

创建一个子类BigPlane:

extends关键字是继承的意思

注意：(1)java是单继承结构，即一个子类只能继承自一个父类

(2)java支持多重继承,即一个类能被多个子类继承

class BigPlane extends Plane{
    //子父类之间的构造方法
    public BigPlane(String color){
        super(color);
    }
    public BigPlane(String code,String color){
        super(code,color);
    }
//重写父类的方法fly()
    @Override
    public void fly(){
        System.out.println("重写后的飞机");
    }

}

重写:子类对父类中继承过来的方法重新定义（方法重写） 可以使用@Override注解，验证方法是否是重写的方法

注意：重写的方法返回值，方法名，参数列表不能发生变化，重写的方法的访问权限只能更开放，不能更闭塞

调用父类的构造方法：

子类的构造方法的首行必须要用父类的构造方法
默认调用父类的无参构造方法
如果父类中没有没有无参构造方法，子类构造方法中必须明文声明调用父类的哪一个构造方法
使用super关键字调用父类的构造方法

    public BigPlane(String color){
        super(color, color);
    }

    public BigPlane(String code,String color){
        super(code,color);
    }

向上转型：

    //用父类的指针指向子类的对象
    public static void main(String[] args) {
        BigPlane bp = new BigPlane("111");
        bp.code="10011";
        bp.fly();
        //父类的指针指向子类的对象
        Plane p = new BigPlane("222");
        //调用方法看对象（看调用的是具体哪一个的对象）
        //调用属性看声明（Plane）
        p.fly();
    }

11.多态：

创建一个父类Parent,两个子类SonA和SonB

class Parent{
    public void method(){
        System.out.println("父类");
    }
}
class SonA extends Parent{
    public void method(){
        System.out.println("A类");
    }
}
class SonB extends Parent{
    public void method(){
        System.out.println("B类");
    }
}

写一个返回Parent类型值的方法getObj():

    public static Parent getObj(int a){
        if (a==1){
            return new SonA();
        }else if (a==2){
            return new SonB();
        }else {
            return new Parent();
        }
    }

在主函数中：

    public static void main(String[] args) {
        int num=1;
        Parent p=getObj(num);//产生多态，因为p变量可能指向任意个子类的对象
        p.method();
    }
}

多态：调用方法可能出现多种结果        多态分为静态多态和动态多态
静态多态：主要是因为重载造成的，在类编译时就可以确定调用的是哪一个方法
动态多态：主要由重写造成的，只有在执行到该行代码，才能确定执行的是哪个类中的方法