Java 函数、类、枚举、接口、泛型、lambda表达式

￡神魔★判官ぃ 2023-02-10 14:29 78阅读 0赞

### 目录 ###

*   *   *  方法 | 函数
         *   *  递归函数
             *  构造函数
             *  函数重载
             *  参数个数可变
         *  类
         *   *  面向对象的3大特性
             *  内部类
             *  抽象类
         *  枚举
         *  接口
         *  泛型
         *  lambda表达式

### 方法 | 函数 ###

#### 递归函数 ####

在方法体内调用方法本身，方法要有出口。

#### 构造函数 ####

如果没有显式提供构造函数，会自动提供一个无参的构造函数作为默认的构造函数；如果显式提供了构造函数，则不再自动提供默认的构造函数。

如果子类显式提供了构造函数

*  如果显式调用了父类的构造函数：则调用语句必须是函数体中的第一个语句
 *  如果没有显式调用父类的构造函数：会自动在函数体的首行调用父类的无参构造函数，如果父类没有提供无参的构造函数，则编译报错

不能直接使用 父类名() 的方式调用父类的构造方法，要通过 super() 来调用，super() 只能在构造方法中使用。

可以在实例方法中通过super对象可以访问父类的成员，super对象属于实例、不是类的公共属性，不能在静态方法中使用super对象。

#### 函数重载 ####

函数重载、重写的区别

*  重载 overload：发生在同一个类中，方法名相同，但参数类型或个数不同，与返回值类型、访问修饰符无关。
 *  重写 override：发生在子类中，修改、覆盖父类方法的实现，只能重写被继承的方法（访问权限不为private），方法名、形参表都必须相同，返回值类型要属于（小于等于）父类方法的返回值类型，抛出的异常要属于（小于等于）父类方法抛出异常，方法访问权限要大于等于父类

构造方法不能被重写，但可以被重载。

#### 参数个数可变 ####

放在形参表末尾，调用时该位置可传入0个或多个指定类型的参数，实质是以数组方式传入，在函数体中以数组方式进行操作。

public void test(String str, String... args) { 
    	//jvm会预先创建一个数组来接收个数可变的参数，即使传了0个参数，args也不为null
    	//可根据数组的元素个数来判断是否传入了参数
        if(args.length!=0){ 
            for (String arg : args) { 
            	//...
            }
        }
    }

*  传参方式：java只有一种传参方式——传值，把实参的值拷贝一份传给形参。拷贝使用的是浅拷贝，基本数据类型、String拷贝的是其中的数值常量、字符串常量，修改形参不会影响到实参；引用类型拷贝的是对象引用，形参、实参指向同一个对象，修改形参就是修改实参。

### 类 ###

#### 面向对象的3大特性 ####

**继承**

在子类的构造函数中，可以

super(xxx);   //调用父类带参的构造函数，必须放在方法体的第一行

如果在构造函数中没有显式调用父类的构造函数，会在执行构造函数之前自动调用父类无参的构造函数。

重写父类的方法

*  方法名相同、形参表相同
 *  如果父类方法是类方法（static）| 实例方法，子类方法也要是static | 实例方法，与父类保持一致
 *  子类方法的返回值类型要 <= 父类方法的返回值类型
 *  子类方法抛出的异常类型要 <= 父类方法抛出的异常类型
 *  子类方法的访问权限要 >= 父类方法的访问权限（如果父类方法使用private修饰，则子类不会继承该方法，也就不能重写）

在子类中访问父类的成员

super(xxx)  //调用父类的构造函数
    super.xxx   //访问父类的成员变量（要有权限才可以）
    super.xxx(xxx)  //调用父类的成员方法

创建对象时，会先初始化这个类所有的父类。

**多态**

引用型变量有2个类型：编译时类型、运行时类型。

编译时类型是声明该变量时的类型，运行时类型是实际赋给该变量的类型。

多态：运行时类型可以不一致。

public void f(User user) { 
    
    }

编译时类型是User，假设User有2个子类Student、Teacher，运行时可以传入Student、Teacher类的对象，类型不一致，即多态。

判断某个引用型变量是否是某个类 | 接口的实例

User user = new User();
    if(user instanceof User){   //返回boolean值
    
    }

变量 instanceof 类 | 接口名，变量要声明为该类|接口类型，否则通不过编译。

#### 内部类 ####

内部类：类中嵌套其它类的定义

匿名内部类：没有类名的内部类，只能使用一次，可以用来实现接口、抽象类，会在该处创建匿名内部类的一个实例，可以用new来写实现。

静态内部类：使用static修饰的内部类，可以通过 外部类.内部类 的方式进行访问。

#### 抽象类 ####

*  抽象类本身使用abstract修饰，不能被实例化，是用来被继承、重写的。
 *  抽象方法使用abstract修饰，没有方法体。
 *  抽象类中可以不含抽象方法，但如果类中有抽象方法，该类必须声明为抽象类。

### 枚举 ###

枚举常用于表示同一种类的常量集合，比如订单状态、用户角色、职称等。

以前的方式

public class Role { 
        public static final String COMMON = "common";
        public static final String VIP = "vip";
        public static final String SVIP = "svip";
    }

枚举

//成员变量+私有构造器+getter方法
    public enum Role { 
    
    	//实质是调用构造函数创建当前类的实例，作为类的静态成员
        COMMON("common"), VIP("vip"), SVIP("svip");
    
        private String role;
    
        private Role(String role) { 
            this.role = role;
        }
    
        public String getRole() { 
            return this.role;
        }
    }
    
    
    //可以不要成员变量
    public enum Role { 
        COMMON, VIP, SVIP;
    }

枚举在编译后会产生一个.class文件，使用javap反编译.class文件得到的java代码如下

public final class Role extends Enum<Role> { 
    
        public static final Role COMMON;
    
        public static final Role VIP;
    
        public static final Role SVIP;
    
        public static Role[] values();
    
        public static Role valueOf(String);
    
        public String getRole();
    
        static { 
    
        }
    
    }

*  编译时会把枚举替换成一个对应的类，且使用final修饰，不能被继承。
 *  枚举对对应的类会继承抽象类Enum，java中的类只支持单继承，不能再继承其它类。
 *  枚举实例会以类的实例的形式做为类的静态成员，使用static final修饰。

### 接口 ###

*  类是对实例的抽象，抽象类、接口是对类的抽象。
 *  接口定义程序设计规范，本身并不提供任何实现，体现了规范（设计）、实现分离的设计方式。

public interface Xxx { 
        // 成员变量默认使用public static final修饰，即常量，在声明时就必须指定初始值
        String XXX = "";
    
        // 方法默认使用public abstract修饰
        String xxx();
    
    
        // 可以定义默认方法，但必须要有方法体
        default void test2() { 
    
        }
    
        //接口中可以定义静态方法方法，但必须要有方法体，默认使用（也只能使用）public修饰
        static void test3() { 
    
        }
    
        // 内部也可以定义类、接口、接口，均默认使用（也只能使用）public static修饰
    
        // 不能有构造函数、初始化块、私有方法
    
    }

// 类只支持单继承，接口支持多继承
    class 类A extends 类B { 
    
    }
    
    interface 接口A extends 接口B, 接口C { 
    
    }
    
    
    // 一个类可以实现多个接口
    class 类A implements 接口A, 接口B { 
    
    }
    
    // 类在继承的同时可以实现接口
    class 类A extends 类B implements 接口A, 接口B { 
        
    }

接口、抽象类的区别

*  接口中只能定义常量、方法，不能表达对象状态的变化（常量不可变）；抽象类中可以定义对象的成员字段，可以表达对象状态的变化。
 *  接口中成员的访问权限默认为且只能为 public，方法可以abstract、default、static之一修饰，默认使用 abstract 修饰，抽象类则无此限制。
 *  类可以同时实现多个接口，但不能同时继承多个类。

一般把子类共有的成员变量、实现相同的公共方法抽象出来放在抽象类中，实现不同的公共方法也可以作为抽象方法放在抽象类中；子类中公共的常量，以及实现不同的公共方法，可以放在接口中。

### 泛型 ###

泛型可以限制对象|元素类型，在编译时对数据类型进行校验。

//在普通的成员变量中使用泛型
    public class Test<T> { 
    
        private T t;
    
        public Test(T t) { 
            this.t = t;
        }
    
        public T getT() { 
            return t;
        }
    
        public void setT(T t) { 
            this.t = t;
        }
        
    }

//静态成员字段不能使用泛型，但静态方法的返回值类型、参数类型可以使用泛型
    class Test { 
    
    	//需要在返回值类型前用< >进行声明
        public static <T> T test(T t) { 
            return t;
        }
        
    }

//类名后面标注的泛型可以用extend指定上边界，但不能用super指定下边界
    public class Test<T extends Number> { 
    
    }
    
    
    //可以使用多个泛型
    public class Test<T extends Number, E> { 
    
    }
    
    
    public class Test<T> { 
    
        //使用泛型声明变量、返回值类型时，可以用? extend指定上边界，必须要是Number的子类
        public Test<? extends Number> handler1(Test<? extends Number> test) { 
            return test;
        }
    
        //可以用? super声明下边界，必须要是Integer的父类
        public void handler2(Test<? super Integer> test) { 
    
        }
    
    	//上边界、下边界都包含边界本身
    	
    }

注意点

*  泛型不能使用int、float等基本类型
 *  编译时会擦除泛型，生成的字节码中没有泛型。
 *  对于同一个类，不管使用哪种泛型，都是同一个类，getClass()获取到的都是同一个Class对象，实例都属于同一个类。
 *  静态成员变量不能使用泛型，是因为类加载时会初始化静态成员，如果使用泛型则不能确定数据类型，无法赋初值。

### lambda表达式 ###

函数式接口：接口中的抽象方法有且只有1个。可以有其它成员，但抽象方法必须要有且只能有1个。

lambda表达式是函数式接口的匿名内部类实现的语法糖，可以代替函数式接口的匿名内部类，只能代替函数式接口的匿名内部类，不能代替其它的匿名内部类。

@FunctionalInterface   //声明为函数式接口
    interface FI { 
        void out(String str1,String str2);
    }
    
    
    class T{ 
        
        // lambda表达式
        private FI fi = (str,str2) -> {   //参数表直接写参数名，不写类型
            System.out.println(str + " " + str2);
        };
        
    }

lambda表达式用于实现函数式接口、并在该处创建一个实例，和匿名内部类相似，但匿名内部类可以实现任何抽象类、接口，lambda表达式只能实现函数式接口。

lambda表达式语法

(形参表) -> {   //形参表不写参数类型，直接写参数名
    　　//......
    }

lambda表达式其实就是函数式接口中抽象方法的实现。

只有一个形参时，可以缺省（）；函数体只有一条语句，且该语句是return语句时，可以缺省\{ \}、关键字return。