Java学习（第三天）

方法的定义:

返回值类型  方法名(参数列表){方法体}

返回值类型:该方法必须返回一个这个类型对象

例:

static void sort(int[] arr){
    for(int i=0;i<arr.iength-1;i++){
        for(int j=0;j<arr.length-1-i;j++){
            if(arr[j]>arr[j+1]){
                int t=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=t;
            }
        }
    }
    return;
}

上面就是一个实现整数类型数组内元素排序的方法,返回值类型为void(无返回值),方法名为sort

使用void类型可以写return,但不能return任何值(也不能是null),此处的作用为终止方法(不写也可)

 调用

sort(数组);

参数有: 实参 形参

定义方法时，参数列表的参数名是形参;

调用时，实际传入的参数就是实参;

可变参数

声明 

sum(int... a){}

使用: 将可变参数当做数组使用

注意: 1.一个方法中只能有一个可变参数

2.可变参数必须在参数列表的最后一个

3.数量可变类型不可变

4.调用可变参数方法，可以使用数组代替

5.可变参数可以不传

递归

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

以上是使用递归实现的阶乘方法

重载

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

参数列表要素

1.参数类型不一样

2.参数个数不一样

3.参数的顺序不同

例:

public static void printMax(int a, int b) {
        System.out.println(a>b?a:b);
    }
public static void printMax(double a, double b) {
        System.out.println(a>b?a:b);
    }

排序算法

static void sort1(int[] arr){//冒泡排序
    for (int i = 0; i < a.length - 1; i++) {
        for (int j = 0; j < a.length - 1 - i; j++) {
            if (a[j+1] < a[j]) {
                int t = a[j];
                a[j] = a[j+1];
                a[j+1] = t;
            }
        }
    }
}
static void sort2(int[] arr){//选择排序
    for (int i = 0; i < a.length - 1; i++) {
        for (int j = i + 1; j < a.length; j++) {
            if (a[j] < a[i]) {
                int t = a[j];
                a[j] = a[i];
                a[i] = t;
            }
        }
    }
}
static void sort3(int[] arr) {//插入排序
        for (int i = 1; i < arr.length; i++) {
            int key = arr[i];
            int j = i - 1;
            //移动arr[0..i-1]中大于key的元素，
            //比他们目前的位置领先一个位置
            while (j >= 0 && arr[j] > key) {
                arr[j + 1] = arr[j];
                j--;
            }
            arr[j + 1] = key;
        }
    }

类的定义

//访问修饰符  关键字class  类名
public class ClassName{
    // 类的成员变量,方法等
    // 属性(全局变量)
    private int num1;
    public String num2;

    // 方法
    public void methodName() {
        // 方法体
    }

    //构造方法
    public ClassName() {
        // 构造方法体
    }
}

定义构造方法

1.没有返回值类型

2.方法名和类名一样

3.如果一个类没有定义任何的构造方法,系统会给与一个默认的空的构造方法

4.类中一旦自定义了任意构造方法,系统给定默认构造方法就消失了 

import java.math.BigDecimal;

public class Staff {
    String code;
    String sex;
    String name;
    double salary;

    //通过构造方法设置属性
    Staff(String name){
        //将参数name设置给name属性
        //就近原则
        //局部变量: 方法体或者代码块中声明的变量
        //全局变量: 在类中定义的变量
        //在局部变量和全局变量重名的情况下,可以使用this关键字,标注全局变量

        this.name=name;
    }
    
    public void work(){
        System.out.println(name+"正在工作");
    }
}

public class TestStaff {

    public static void main(String[] args) {
        //实例化对象  开辟内存空间
        Staff staff=new Staff();

        //设置对象的属性   类中声明了那些属性,对象中就有哪些属性
        staff.code="YG10001";
        staff.name="张三";
        staff.sex="男";
        staff.salary=10000;
        Staff staffA=new Staff();
        staffA.code="YG10002";
        staffA.name="李四";
        staffA.sex="女";
        staffA.salary=12000;


        //调用对象的方法
        staff.work();
        staffA.work();
    }
}

面相对象特征(特性) : 封装------------继承------------多态 

封装: 隐藏细节,不能让类随意访问  通过四个访问权限修饰符达到封装的效果

访问修饰符: 可以使用访问修饰符来限制类、成员变量和方法的访问范围。常见的访问修饰符包括 public（公共的，可以被任何类访问）、private（私有的，只能在同一个类中访问）、protected（受保护的，同包内及子类可访问）、以及默认访问修饰符（default)（不写任何修饰符，同包内可访问）。

继承: 一个类继承父类,子类就具有父类中定义好属性和方法

不是所有的属性和方法都能访问到  public  protected  本包下的父类default可以访问

1.代码重用

2.多态实现的基础

注意: 1.一个子类只能有一个直接父类 2.java支持多重继承

class Plane {
    public Plane(String code) {
        this.code = code;
    }

    public Plane(String code, String color) {
        this.code = code;
        this.color = color;
    }

    protected String code;  /* protected 子类  本包下*/
    String color;

    protected void fly() {
        System.out.println("看,天上有个大飞机");
    }
}

class BigPlane extends Plane {
    //子类继承父类
    //子类对父类中继承过来的方法重新定义:方法重写
    //可以使用@Override注解,验证方法是否是重写的方法
    /*注意: 返回值,方法名,参数列表不能发生变化
          重写的方法的访问权限只能更开放,不能更闭塞*/
    @Override
    public void fly() {
        System.out.println("看,天上有个更大的飞机");
    }

    public String code;

    //子父类间的构造方法
    public BigPlane(String code) {
        //子类的构造方法中首行必须要用父类的构造方法
        //默认调用父类的无参构造方法
        //父类中没有无参构造方法,子类构造方法中必须明文声明调用父类哪一个构造方法
        //使用super关键字调用父类的构造方法
        super(code);
    }

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

}

多态: 

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=2;
        Parent p=getObj(num);//p这个变量可能指向任意个子类的对象
        p.method();//多态: 调用方法时可能会出现多种结果
        //多态分类:
        //静态多态:重载造成,在类编译(javac)时就可以确定调用的是哪一个方法
        //动态多态:重写造成,只有在执行到该代码,才能确定执行的是哪个类中的方法
    }

}
class Parent{
    public  void  method(){
        System.out.println("parent");
    }
}

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

调用方法看对象，调用属性看声明；