Java学习笔记3

方法

又可以称为函数/过程

语法

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

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

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

    null值 void中不能return null

void中return可以直接写表示方法结束

public static int max(int a, int b) {

        int max = a > b ? a : b;

        //return返回数据

        return max;

    }

        //得到最大值

        //调用本类中已经定义好的方法

public static void printMaxA(int a, int b) {

        int result = max(a, b);

        //打印

        System.out.println(result);

    }

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

    实参：调用方法时，实际传入的参数

//上代码中

public static void printMaxA(int a, int b) 

此处int a,int b就是形参没有具体数值

        int result = max(a, b)

此处a,b为实参调用时是一定会有具体数值。

重载

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

    参数列表要素

    1.参数类型不同

public static void max(byte a, byte b) {

    }

    2.参数的个数不同

public static void max(int a, int b, int c) {

    }

    3.参数的顺序不同

public static void max(int a, byte b) {

    }

    public static void max(byte a, int b) {

}

    可变参数,类型后面跟三个点...

    声明 sum(int... a){}

    使用  将可变参数当作数组使用

    注意点：

    1.参数列表一个方法中最多只有一个可变参数

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

    错误示范public static int sum(int a,int... b,int c){}

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

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

    5.可变参数可以不传

递归，方法自身调用用自身

    //最经典阶乘例如 !99    

public static int jieCheng(int num) {

        if (num == 1) {

            return 1;

        }

        return num * jieCheng(num - 1);

    }

    public static void main(String[] args) {

        System.out.println(jieCheng(99));

    }

}

冒泡排序

前后两个相邻元素比较

如果前面的元素大，就交换位置

 数组越界的可能
 

public static void maopaopaixv(int[] arr) {

        for (int j = 0; j < arr.length - 1; j++) {

            for (int i = 0; i < arr.length - 1 - j; i++) {

                //前后两个相邻元素比较

                //如果前面的元素大，就交换位置

                //数组越界的可能

                if (arr[i] > arr[i + 1]) {

                    int temp = arr[i];

                    arr[i] = arr[i + 1];

                    arr[i + 1] = temp;

                }

            }

        }

        System.out.println(Arrays.toString(arr));

    }



    public static void main(String[] args) {

        int[] arr = {7, 4, 89, 2, 6, 123, 8, 796, 56, 11, 1};

        maopaopaixv(arr);

}

类

    //定义构造方法

    //1.没有返回值类型

    //2.方法名和类名一样

    //3.如果一个类没有定义任意的构造方法，系统会给予一个默认的构造方法。

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

    Staff() {  

 }

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

全局变量：在类中定义的变量

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

通过构造方法设置属性
   

 Staff(String name,String code, String sex,double salary) {

        this.name = name;

        this.code = code;

        this.sex = sex;

        this.salary = salary;

    }

   

     String code;

     String sex;

     String name;
 
     double salary;

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

public void work() {

        System.out.println(name + "正在工作");

    }

调用类实例

public static void main(String[] args) {

        //实例化对象 开辟内存空间

        Staff staff = new Staff();

        //设置对象的属性  类中声明了哪些属性，对象中就有哪些属性

        staff.code="TG000001";

        staff.name= "张三";

        staff.sex= "男";

        staff.salary=15000;





        Staff staffA = new Staff();

        staffA.code="TG000000";

        staffA.name= "李四";

        staffA.sex= "男";

        staffA.salary=10000;



        //调用对象的方法

        staff.work();

        staffA.work();



    }

封装，继承，多态

封装

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

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

    //public         protected               default            private

    //公共的    受保护的（家族性的）    默认（本包下的）  私有的（只能在本类中访问）

继承

//继承    一个类（子类）可以继承另外一个类（父类），子类可以拥有父类中定义好的属性和方法   A（子类） extends B（父类）

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

    //1.代码重用

    //2.多态实现的基础

    //注意：

    //1.一个子类只能有一个直接父类

//2.Java支持多重继承 

public static void main(String[] args) {

        BigPlane bp = new BigPlane("1011");

        bp.code = "100001";

        bp.fly();



        Plane p = new BigPlane("1011");

        //调用法看对象

        //调用属性看变量的声明

        p.fly();

    }

}



class Plane {

    public Plane(String code) {

        this.code = code;

    }



    protected String code;//子类以及本包下的类可以访问到

    String color;



    public void fly() {

        System.out.println("看，天上有个大飞机");

    }

}



class BigPlane extends Plane {

    //子类继承父类

    //重写

    //子类对父类中继承过来的方法进行重新定义：方法重写

    //可以使用@Override注解来验证方法是否是重写的方法

    //注意：返回值，方法名，参数列表不能发生变化

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





    //子父类间的构造方法

    public BigPlane(String code) {

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

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

        //父类中没有默认的无参构造方法，子类的构造方法中必须明文说明调用父类哪一个构造方法

        //子类构造方法中使用super关键字调用父类的构造方法

        super(code);

    }

    @Override

    public void fly() {

        System.out.println("看，天上有个更大的飞ffff机");

    }

多态

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

多态分类:

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

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

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");

    }