java学习笔记3

一、方法：

在Java中，方法是一段用来执行特定任务的代码，它包括：返回值类型 方法名（参数列表）和方法体。
方法分为 成员方法，类方法（有static修饰）

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

1. 当一个方法不需要返回值，返回值类型定义为void。
2. void中不能return null
3. void中能写return，代表方法结束;但是不能写return 值。

2. 方法的调用：

1. 方法名(参数); 调用本类静态方法。
2. 类名. 方法名(参数) ；调用其他类中的静态方法。
3. 调用非静态方法 先实例化对象，通过 对象.方法名(参数); 调用。

3. 参数：

形参：定义方法时，参数列表的参数名。
实参：调用方法时实际传入的参数。

4. 重载：在同一个类中，方法名相同参数列表不同，即为重载。（和是否返回值，返回值类型无关）

参数列表要素：

1. 参数类型不同
2. 参数的个数不同
3. 参数的顺序不同

5. 可变参数：

声明 sum(int… a){ }

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

public static int sum(int... a){//可变参数
       int sum=0;
       for(int item:a)//每次取一个参数a给item
       {
           sum+=item;
       }
        return sum;
    }
     public static void main(String[] aavgrgs) {
        System.out.println(sum(1,2,3,3,5,6,57,78,99));

        int [] arr = {1,2,3,4,5,6,7,8,9};
        sum(arr);//调用可变参数方法，可以使用数组代替
    }

注意：

1. 一个方法只能有一个可变参数
   2. 可变参数必须在参数列表的最后一个
   3. 可变参数是数量可变，类型不可变
   4. 调用可变参数方法，可以使用数组代替
   5. 可变参数可以不传

6. 递归，方法自身调用自身
   如：求一个数的阶乘

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

7. 冒泡排序

 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++) {
                //如果前面的元素大，就交换位置
                if (arr[i] > arr[i + 1]) {
                    int temp = arr[i];
                    arr[i] = arr[i + 1];
                    arr[i + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] aavgrgs) {
        int[] arr = {199, 28, 37, 54, 57, 46, 72, 38, 19, 0};
        maopao(arr);
        System.out.println(Arrays.toString(arr));
    }

8. 构造方法 public class 类名(和方法名一样) { }

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

9. 就近原则：当Java虚拟机（JVM）执行方法调用或变量访问时，它会首先在当前作用域内查找匹配的方法或变量。如果当前作用域没有找到，它会继续向外层作用域逐级查找，直到找到为止。

Staff(String name){//将参数name设置为name属性
        //就近原则
        this.name=name;//在局部变量和全局变量重名的情况下可以使用this关键字标注全局变量
    }

10. 全局变量：在类中定义的属性（变量）。
    局部变量：在方法体或者代码块中声明的变量。
    类中的方法可以直接调用本类中的属性。
    在局部变量和全局变量重名的情况下可以使用this关键字标注全局变量。
11. 创建对象时（实例化），使用new关键字在内存开辟空间，在空间中创建对象，并调用构造方法对对象初始化。
12. 创建对象四种方法：

1. 使用new关键字
2. 克隆
3. 反序列化
4. 反射

Staff sf=new Staff();
sf.name="张三";//设置对象的属性，类中声明了哪些属性和方法对象中就有哪些属性和方法  对象.属性=" ";
sf.work();//类中的方法，通过 对象.方法(参数); 调用。

二、面向对象的三大特征

封装，继承，多态

1. 封装：隐藏类或方法的细节，不能让其他类随意的访问。

通过四个访问权限修饰符来达到封装的效果
public公共的（都可以访问），protectde受保护的（家族性的，有继承关系才能访问），default默认（只能在本包中访问），private私有的（只能在本类中访问）

getter和setter方法以及javabean都是经典的封装

getter和setter方法用于访问和修改对象的私有属性

2. 继承(extends)：一个类可以继承另外一个类，子类具有父类中定义好的属性和方法。

1. 不是所有的属性和方法都能访问的,访问权限见上图。

继承的好处：

1. 实现代码重用
2. 多态实现的基础

注意:
一个子类只能有一个直接父类(java不支持多继承)

2. (1) 向上转型：声明一个父类类型的引用指向一个子类的对象。

语法：父类类型 对象名 = new 子类类型()

Animal   animal  =  new Cat ();

 Plane p = new BigPlane("1003");//子类的对象指向父类
 //调用方法看对象//调用属性看变量的声明

创建一个子类对象，将其当成父类对象来使用。
向上转型是对A的对象的方法的扩充，即A的对象可访问B从A中继承来的和B“重写”A的方法。
向上转型并非是将B自动向上转型为A的对象，相反它是从另一种角度去理解向上两字的：它是对A的对象的方法的扩充，即A的对象可访问B从A中继承来的和B复写A的方法,B中的其它的方法都不能访问

 class A {
        void f() {
        }

        void g() {
        }
    }

    class B extends A {
        void g() {
        }

        void i() {
        }
    }

    public class C {
        public static void main(String[] avg) {
            A a = new B(); //B自动向上转型为A的对象
        }
    }

2. (2)方法重写：子类对父类中继承过来的方法重新定义。通过子类对象调用被重写的方法时，会自动调用子类中的方法。

可以使用@override注解，验证方法是否是重写的方法

注意：
1. 返回值，方法名，参数列表不能发生变化
2. 重写的方法的访问权限只能更开放，不能更闭塞
3. 重写的方法抛出的异常只能更精确(范围更小),不能扩大

2. (3)子父类之间的构造方法

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

3. 多态：调用方法时可能出现多种结果。

多态的分类：
静态多态：重载造成，在类编译时就可以确定调用的是哪一个方法
动态多态：重写造成，只有在执行到该行代码，才能确定执行的是哪个类的方法

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[] avg) {
        int num=2;
        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");
    }
}