接口，内部类，泛型Java

最新推荐文章于 2024-11-04 15:37:16 发布

小锦鲤yaw

最新推荐文章于 2024-11-04 15:37:16 发布

阅读量52

点赞数 1

分类专栏： Java语法文章标签：数据结构

本文链接：https://blog.csdn.net/m0_57248981/article/details/129303156

版权

Java语法专栏收录该内容

22 篇文章 0 订阅

订阅专栏

4.匿名内部类 Lambda 表达式的前身

4.泛型

1.泛型接口

2.泛型数组

1.接口

Collect：保存单个元素的父接口

-List：保存重复单个元素的接口 ArrayList LinkedList

-Set：保存单个不重复元素的接口 -》用于去重处理 HashSet TreeSet

Map接口：保存键值对元素的接口

key值在集合中不重复，value可以重复 key = value 例如：身份证号 -> 人名

遍历集合的工具：迭代器

Iterator

List Iterator 线性

对象比较 Comparable Comparator

工具类 Arrays Collections

2.时间与空间复杂度

1.时间复杂度：不是具体的时间，算法执行的基本次数

大O阶（看最坏情况）

1.用常数1取代所有加法常数

2.只保留最高阶

3.最高阶项数不是一，则系数也去掉

log N

2.空间复杂度：描述算法运行过程中额外占用（New）的内存大小，算法本身运行所占空间不算在内

3.内部类

1.概念

就是一个类嵌套在另一个类的内部，这个嵌套类就是内部类，也是封装的一种体现（可以用private修饰）

public class Test01 {
    class Test02{
        
    }
}

2.内部分类

$用在编译后标识内部类

1.成员内部类

定义在类中，不加static修饰的内部类，成员内部类中不可定义静态属性或方法

（⭐内外部类可以互相访问私有属性），成员内部类可直接调用外部类的私有属性，外部类需要通过内部类的对象来访问内部类的私有属性

产生内部类的对象：1.在外部类的内部产生类名称引用名称 = New 类名称（）

2.若内部类私有化，则在内部类的外部不可产生对象，否则

外部类名称.内部类名称引用 = New 外部类（）.New 内部类（）

2.静态内部类

1.直接定义在类的内部，使用static修饰的内部类，可以定义静态属性也可以定义成员变量

静态内部类不需要外部对象，可以直接访问外部类的静态域

2.在外部类的内部产生静态内部类的对象，类名称引用名称 = New 类名称（）

在外部类的外部产生，外部类名称.内部类名称引用 = New 外部类.New 内部类（）

成员内部类中包含了外部内部类的对象，能直接访问外部类的成员属性，不能定义静态属性

静态内部类中没有包含外部类的对象，可以定义静态变量与成员属性，不能直接访问外部类的成员属性

2.3.通过内部类规避单继承局限~

以下两种内部类都是定义在方法中的

3.方法内部类

1.直接定义在方法中，不能有任何访问修饰符，方法调用结束，自动销毁

2.只能在方法中产生方法内部类的对象

3.方法内部类要使用方法中的形参，这个参数必须为形式上的final（不能修改）

public void test(){
            //方法内部类
            class Inner{
                private int num;
                public void test01(){
                    System.out.println(name);
                }
            }
            Inner inner = new Inner();
            inner.test01();
            System.out.println(Test01.this.name);
        }

4.匿名内部类 Lambda 表达式的前身

定义在方法之中，主要在方法的参数上使用，这个类没有名字，一般默认继承一个类或者实现一个接口

interface InterFase{
    void print();
}

public class NonNameClass {
    public void fun(){
        //匿名内部类
        new InterFase(){
            @Override
            public void print() {
                
            }
        };
    }
}

4.泛型

在定义类或者方法时，参数的类型暂定(可以有多个，一般用单个的大写字母表示E,T,K,键值对搭配使用)，只有在使用时，才明确类型~

public class MyPoint <T>{
    private T x;
    private T y;
}

public class MyPointTest {
    public static void main(String[] args) {
        MyPoint<Integer> myPoint = new MyPoint<>();
        myPoint.setX(1);
        myPoint.setY(20);
        System.out.println(myPoint.toString());
    }
}

泛型方法可以不在泛型类中

public static <T>void fun(T t){
        System.out.println("这是一个泛型方法");
        System.out.println(t);
    }

1.泛型接口

1.子类仍是泛型类

2.子类明确具体类型

2.泛型数组

1.不存在New 类型参数的数组

但可以声明，用泛型后类型一旦明确，就不可改变，与Object不同

class Arr<T>{
    //标准定义
    private Object[] value = new Object[10];
    private int size;

    public void add(T t){
        value[size++] = t;
    }

}