java学习记录（day3）

一、方法

又称 函数、过程

语法

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

1.有返回值

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

应用实例

2.无返回值

当一个方法不需要返回值   返回值就定义为void

void 中不能返回NULL

void 能写return

3.参数

3.1定义

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

实参：实际传入的值

3.2可变参数

3.2.1声明

sum(int... a){

}

3.2.2使用

将可变参数当作数组使用

注意点：

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

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

3.数量可变，类型不可变

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

5.可变参数可以不传

4.重载

4.1定义

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

4.2参数列表要素

1.参数类型不同

2.参数个数不同

3.参数个数不同

4.参数顺序不同

5.递归

方法自身调用自身

阶乘练习如下：

构造方法

1.定义构造方法

1.没有返回值类型

2.方法名和类名一样

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

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

2.变量

全局变量：类中声明的变量

局部变量：方法体或者代码块中声明的变量

类中的方法可以直接调用本类中的属性

3.通过构造方法设置属性

就近原则：在局部变量和全局变量重名的情况下可以使用this关键字标注全局变量

4.实例应用

二、排序

1.冒泡排序

三、面向对象的特征

封装、继承、多态

1.封装

1.1定义

隐藏细节，包括属性和方法，不能让其他类随意的访问

1.2实现

通过四个访问权限修饰符来达到封装的效果

public   公共的

protected    受保护的（家族性）

default    默认的（本包中）

private   私有的（本类中）

使用私有的（private）变量

1.3实例应用

package com.easyb;

import java.util.Arrays;

public class NumList {
    /**
     * 存储数字
     * */
    private int[] values;
    /**
     * 记录数量
     * */
    private int size=0;
    /**新元素应该存到的下标位置*/
    private int index=0;
    public NumList(int capacity){
        this.values=new int[capacity];
    }
    public void add(int item){
        //将传入的参数存到value数组，index++  size++
        values[index++]=item;
        size++;
    }
    public int size(){
        return size;
    }
    public int[] getItem() {
        int[] result = new int[size];
        System.arraycopy(values, 0, result, 0, size);
        return result;
    }

    public static void main(String[] args) {
        NumList numList=new NumList(20);
        numList.add(88);
        numList.add(99);
        String arrStr= Arrays.toString(numList.getItem());
        System.out.println(arrStr);
    }
}

2.继承

2.1定义

一个类可以继承父类，子类就具有父类中定义好的属性和方法

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

继承可以代码重用，是多态实现的基础

注意：1.一个子类只能有一个直接父类

2.java支持多重继承

定义一个父类

定义一个子类来继承父类

2.2重写

子类继承父类

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

注意 ：1.返回值、方法名、参数列表不能变化

2.重写的方法，访问权限只能更开放，不能更闭塞

父类中定义的方法：

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

子类中重写的方法：

 @Override
    public void fly(){
        System.out.println("看，天上有个更大的飞机");
    }

2.3子父类之间的构造方法

1.子类的构造方法中首行必须调用父类的构造方法

2.默认调用父类的无参构造方法

3.父类没有无参构造方法，子类构造方法中必须明文声明调用父类哪一个构造方法

4.使用super关键字调用父类的构造方法

父类的构造方法

子类的构造方法

2.4向上转型

2.5完整代码

package com.easyb;

public class EasyD {
    //继承  一个类可以继承父类，子类就具有父类中定义好的属性和方法
    //不是所有的属性和方法都能访问到  public protected  本包下的父类default
    /*1.代码重用
    2.多态实现的基础
     */

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


    //向上转型

    public static void main(String[] args) {
        BigPlane bp=new BigPlane("111");
        bp.code="aaa";
        bp.printcode();

        Plane p=new BigPlane("222");//向上转型
        p.code="bbbb";
        p.printcode();
        //调用方法看对象
        //调用属性看变量的声明

    }
}

class Plane{
    protected String code;/*protected  子类以及本包下的类可以访问到*/
    String color;
    public Plane(String code){
        this.code=code;
    }

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

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


    //子父类之间的构造方法
    //子类的构造方法中首行必须调用父类的构造方法
    //默认调用父类的无参构造方法
    //父类没有无参构造方法，子类构造方法中必须明文声明调用父类哪一个构造方法
    //使用super关键字调用父类的构造方法
    String code;
    public BigPlane(String code){
        super(code);
    }
    public BigPlane(String code,String color){
        super(code,color);
    }
    public void printcode(){
        System.out.println("this.code=="+this.code);
        System.out.println("super.code=="+super.code);
    }

    @Override
    public void fly(){
        System.out.println("看，天上有个更大的飞机");
    }
}

3.多态

多态：调用方法时，可能会出现多种结果

多态分类：1.静态多态：由重载造成的，在类编译时就可以确定调用的是哪一个方法

2.动态多态：由重写造成的，只有在执行到这行代码才能确定执行的是哪个类中的方法 

示例：

package com.easyb;

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.method();//多态：调用方法时，可能会出现多种结果
        //多态分类：
        /*
        静态多态：由重载造成的，在类编译时就可以确定调用的是哪一个方法
        动态多态：由重写造成的，只有在执行到这行代码才能确定执行的是哪个类中的方法
         */
    }
}
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");
    }
}