Java学习Day3

方法

定义：方法（Method）是一组执行特定任务的代码块

方法（函数，过程）
方法语法：
返回值类型   方法名（参数列表）{方法体}
返回值类型：该方法必须返回一个该类型的对象
当一个方法不需要返回值，返回值类型就定义为void
void下能写return，但不能return null

return 终止方法的作用
public static int max(int a ,int b){
    int max=a>b?a:b;
    //用return返回数据
    return max;
}

参数

参数分为形参和实参
定义方法时定义的参数列表的参数名  形参
调用方法时传入的参数    实参
方法的重载 在一个类中方法名相同即为重载（方法名相同参数类型不同）
参数列表要素：参数类型不同 ，参数的个数不同 ，参数的顺序不同（指不同类型的参数顺序）
可变参数  声明 sum（int ...a){} 将可变参数当成数组使用。

public static int sum(int... a){
    int sum =0;
    for(int i:a){
        sum+=i;
    }
    return sum;
}

参数注意点
1.一个方法中最多只有一个可变参数
2.可变参数必须放在参数列表的最后一位
3.可变参数是数量可变类型不可变
4.调用可变参数方法，可以使用数组代替可变参数
5.可变参数可以不传（只传前面的其它参数）

递归函数是调用自身的函数（n的阶层）

public static int jiecheng(int n){
    if (n==1){
        return 1;
    }
    return n*jiecheng(n-1);
}

排序算法：

冒泡排序：

public class EasyB {
    public static void main(String[] args) {
        int[] arr = new int[]{10,3,4,99,11,9};
        maopaoSort(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void maopaoSort(int[] arr){
        for (int j=0;j<arr.length-1;j++) {
            //比较一趟，将最大值移到最右侧
            //i+1要注意i的范围,避免发生数组越界
            for (int i = 0; i < arr.length - 1-j; i++) {
                //如果左侧元素大，就交换位置
                if (arr[i] > arr[i + 1]) {
                    int tem = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = tem;
                }
            }
        }
    }
}

类

类的构造方法：

定义构造方法，无返回值类型
方法名和类名一样
如果一个类没有任何构造方法，系统会给与一个默认的空的构造方法
一个类中，一旦自定义了任意的构造方法，系统给定的默认构造方法就消失了

定义一个私有的构造方法

Staff(String name,String code,String sex,BigDecimal salary){
    //将参数name设置给name属性   就近原则在同一个代码块中优先选择代码块中的变量
    // 局部变量：方法体或者代码块中声明的变量
    // 全局变量在类中定义的变量
    // 在局部变量和全局变量重名的情况下，可以使用this关键字来标注全局变量标识
    this.name=name;
    this.code =code;
    this.sex=sex;
    this.salary=salary;
}
//类当中的方法可以直接调用本类中的属性
public void work(){
    System.out.println(name+"正在工作");

}
实例化对象：
public static void main(String[] args){
    //实例化对象
    Staff staff=new Staff();
    //设置对象的属性  类中声明了那些属性，对象中就有那些属性
    staff.code="00001";
    staff.name="Tom";
    staff.sex="男";
    staff.salary=new BigDecimal(10000.0);
    //调用对象的方法
    staff.work();
}

面向对象三大特征 封装 继承 多态

封装

封装：隐藏类细节，不能让其他类随意地访问

通过四个访问权限修饰符达到封装的效果
public  protected            default         private
公共的  受保护的（家族性的） 默认的（本包中）私有的（只能在本类中访问）

public static int num_public = 22;
static int num_default = 33;
private String name;

继承

继承 一个类继承父类，子类就具有父类中定义好属性和方法
不是所有的属性和方法都能访问到 ,在public ，protected（protected 子类或本包下可以访问） 或本包下的父类或子类能访问

一个类只能能继承一个直接父类，但是一个父类可以有多个子类。java支持多重继承，子类可以继承父类，子类也可以作为父类继承给其它子类。

可以向上转型

//Plane为BigPlane的父类
public static void main(String[] args) {
    BigPlane bp = new BigPlane("s");
    bp.code = "10001";
    bp.fly();
    //向上转型
    //调用方法看对象
    //调用属性看声明，那个方法声明的，对象拥有的属性就是那种方法的
    Plane p =new BigPlane("s");
    p.color="red";
    p.print();
    p.fly();
}

子类继承父类
子类对父类中继承过来的方法进行重新定义：方法重写
可以使用@Override注解来验证方法是否是重写的方法
方法重写只能改函数体
注意，返回值，方法名，参数列表不能变化
重写的方法的访问权限只能更开放，不能更闭塞

父类中的一个fly方法为

public void fly() {
    System.out.println("看，天上有个飞机");
}
子类中重写的为
@Override
public void fly(){
    System.out.println("有飞机");
}
子类的构造方法
public BigPlane(String code){
    //子类的构造方法中首行必须要用父类的构造方法
    //默认调用父类的无参构造方法
    //父类中没有无参构造方法，子类构造方法中必须要声明调用父类的那一个构造方法
    //使用super关键字调用父类的构造方法
    super(code);
String mane;
}

多态

分类：静态多态和动态多态
动态多态主要由重写造成，只有执行到该行代码，才能确定执行的那个类中的方法
静态多态主要是由重载造成的，在类编译时（javac）就确认调用的具体是哪一个方法

例如定义一个Parent父类，两个继承子类SonA子类，SonB子类，分别有一个mess方法

public class EasyE {
    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.mess();//多态 调用方法时可能出现多种结果
    }
}