栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

JAVA知识点笔记

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

JAVA知识点笔记

一、 命名

类名首字母大写 && 方法首字母小写 && 变量/方法名遵循驼峰命名

二、 数据类型
  1. 基本数据类型( CPU可以直接进行运算的类型)
    整数类型:byte,short,int,long
    浮点数类型:float,double
    字符类型:char
    布尔类型:boolean
  2. 引用类型:String 字符串
  3. 常量:加上final修饰符,变量就变成了常量
  4. var关键字:只是可以少写变量类型
三、 方法 function

field:单个变量域,用private修饰field,拒绝外部访问

1. 重载 Overload

方法名相同,但各自参数不同(返回值类型通常也相同)
目的是:功能类似的方法使用同一名字,更容易记住

2. 覆写 Override

子类定义了与父类方法签名完全相同的方法

Overload方法签名不同,是一个新方法;
Override方法签名相同,返回值也相同,是重定义父类的方法。

加上@Override可以让编译器帮助检查是否进行了正确的覆写。
希望进行覆写,但是不小心写错了方法签名,编译器会报错。

四、 继承 1. extends

Java使用extends关键字来实现继承

子类自动获得了父类的所有字段,严禁定义与父类重名的字段!

2. super

关键字表示父类(超类)。子类引用父类的字段时,可以用super.fieldName

3. super()

任何class的构造方法,第一行语句必须是调用父类的构造方法。
子类不会继承任何父类的构造方法。(子类默认的构造方法是编译器自动生成的。)
【 如果没有明确地调用父类的构造方法,编译器会帮我们自动加一句super(); 】
但是如果父类没有默认的构造方法,子类就必须显式调用super()并给出参数以便让编译器定位到父类的一个合适的构造方法。

在OOP的术语中,我们把Person称为超类(super class),父类(parent class),基类(base class),把Student称为子类(subclass),扩展类(extended class)。

4. protected

子类无法访问父类的private字段或者private方法。
把private改为protected。用protected修饰的字段可以被子类访问

5. final

如果一个父类不允许子类对它的某个方法进行覆写,可以把该方法标记为final。
用final修饰的方法不能被Override,
用final修饰的类不能被继承,
用final修饰的字段在初始化后不能被修改

6. sealed类

从Java 15开始,允许使用sealed修饰class,并通过permits明确写出能够从该class继承的子类名称。
public sealed class Shape permits Rect, Circle, Triangle {...}
这种sealed类主要用于一些框架,防止继承被滥用

五、多态 Polymorphic

多态是指,针对某个类型的方法调用,其真正执行的方法取决于运行时期实际类型的方法。

功能:允许添加更多类型的子类实现功能扩展,却不需要修改基于父类的代码

六、抽象类 abstract

如果class定义了方法,但没有具体执行代码,这个方法就是抽象方法,用abstract修饰。

因为无法执行抽象方法,因此这个类也必须申明为抽象类(abstract class)。
我们无法实例化一个抽象类

编译器会告诉我们,无法编译,因为包含抽象方法。

抽象类本身被设计成只能用于被继承,因此,抽象类可以强迫子类实现其定义的抽象方法,否则编译会报错。因此,抽象方法实际上相当于定义了“规范”。

七、接口 interface

如果一个抽象类没有字段,全都是抽象方法,就可以把该抽象类改写为接口
( 所有方法默认都是public abstract )

1. 接口实现

当一个具体的class去实现一个interface时,需要使用implements关键字

一个类只能继承自另一个类,不能从多个类继承。但是,一个类可以实现多个interface

2. 接口继承

interface继承自interface使用extends

3. 继承关系

合理设计interface和abstract class的继承关系,可以充分复用代码。一般来说,公共逻辑适合放在abstract class中,具体逻辑放到各个子类,而接口层次代表抽象程度。

List list = new ArrayList(); // 用List接口引用具体子类的实例
Collection coll = list; // 向上转型为Collection接口
Iterable it = coll; // 向上转型为Iterable接口
4. default方法

目的是,当我们需要给接口新增一个方法时,会涉及到修改全部子类。如果新增的是default方法,那么子类就不必全部修改,只需要在需要覆写的地方去覆写新增方法。

八、静态 static 1. 静态字段:static field

实例字段在每个实例中都有自己的一个独立“空间”,但是静态字段只有一个共享“空间”,所有实例都会共享该字段。
可以把静态字段理解为描述class本身的字段(非实例字段)

2. 静态方法

调用实例方法必须通过一个实例变量,
而调用静态方法则不需要实例变量,通过类名就可以调用。
【 静态方法类似其它编程语言的函数。】

静态方法属于class而不属于实例
因此,静态方法内部,无法访问this变量,也无法访问实例字段,它只能访问静态字段。

通过实例变量也可以调用静态方法,但这只是编译器自动帮我们把实例改写成类名而已。
通常情况下,通过实例变量访问静态字段和静态方法,会得到一个编译警告。

3. 接口的静态字段

因为interface是一个纯抽象类,所以它不能定义实例字段。但是,interface是可以有静态字段的,并且静态字段必须为final类型。

public interface Person {
    // 编译器会自动加上public statc final:
    int MALE = 1;
    int FEMALE = 2;
}
九、泛型 Generics

泛型就是编写模板代码来适应任意类型(一套代码创建各种类型);

例如编写ArrayList,就可以创建任意类型的ArrayList
为用到的类创建对应的ArrayList<类型>:

ArrayList strList = new ArrayList();
  1. 优点:使用时不必对类型进行强制转换,它通过编译器对类型进行检查;

注意泛型的继承关系:可以把ArrayList向上转型为List(T不能变!),但不能把ArrayList向上转型为ArrayList(T不能变成父类)

  1. 局限:( Java的泛型是采用擦拭法实现的 )
    1) 不能是基本类型,例如int
    因为实际类型是Object,Object类型无法持有基本类型
    2) 无法取得带泛型的Class。例如:Pair.class;
    无论T的类型是什么,getClass()返回同一个Class实例,因为编译后它们全部都是Pair
    3) 无法判断带泛型的类型。例如:x instanceof Pair;
    4) 不能实例化T类型。例如:new T()

    子类可以获取父类的泛型类型

    十、 集合 Collections

    如果一个Java对象可以在内部持有若干其他Java对象,并对外提供访问接口,我们把这种Java对象称为集合。

    Java标准库自带的java.util包提供了集合类:Collection,它是除Map外所有其他集合类的根接口。

    1. 三种类型的集合: List:一种有序列表的集合
    1. 按索引顺序访问的长度可变的有序表,优先使用ArrayList而不是LinkedList;
    2. 根据给定元素快速创建List:List.of()
    List list = List.of(1, 2, 5); //不接受null值
    
    1. 遍历:使用迭代器Iterator 【 for循环 get(i) 不推荐 】
    2. Iterator对象有两个方法:
      boolean hasNext() 判断是否有下一个元素,
      E next() 返回下一个元素。
    List list = List.of("apple", "pear", "banana");
    for (Iterator it = list.iterator(); it.hasNext(); ) {
        String s = it.next();
        System.out.println(s);
    }
    //简化
    for (String s : list) {
        System.out.println(s);
    }
    
    1. List和Array转换

    把List变为Array:
    1️⃣ 调用toArray()方法直接返回一个Object[]数组

    Object[] array = list.toArray(); //会丢失类型信息
    

    2️⃣ 给toArray(T[])传入一个类型相同的Array,List内部自动把元素复制到传入的Array中

    Integer[] array = list.toArray(new Integer[list.size()]);
    

    3️⃣ 通过List接口定义的T[] toArray(IntFunction generator)方法:

    Integer[] array = list.toArray(Integer[]::new);
    

    把Array变为List:
    1️⃣ 通过List.of(T…)方法最简单

    Integer[] array = { 1, 2, 3 };
    List list = List.of(array);
    

    ( 返回的List不一定就是ArrayList或者LinkedList,因为List只是一个接口,List.of()返回的是一个只读List )

    1. 是否包含某个指定元素:boolean contains(Object o)
    2. 返回某个元素的索引:int indexOf(Object o) 如果元素不存在,就返回-1
    3. 调用List的contains()、indexOf()这些方法,需要实现equals()方法:确定实例哪些字段相等,就认为实例相等
    4. 对引用类型用Objects.equals()比较,对基本类型直接用==比较
    public boolean equals(Object o) {
        if (o instanceof Person) {
            Person p = (Person) o;
            return Objects.equals(this.name, p.name) && this.age == p.age;
        }
        return false;
    }
    
    Set:一种保证没有重复元素的集合
    1. 添加元素:boolean add(E e)
    2. 删除元素:boolean remove(Object e)
    3. 判断是否包含元素:boolean contains(Object e)
    Map:一种通过键值(key-value)查找的映射表集合
    1. 映射入表:put(K key, V value)
    2. 通过key获取对应的value:get(K key)
    3. 查询某个key是否存在:boolean containsKey(K key)
    4. 遍历key:通过for each遍历keySet()
    for (String key : map.keySet()) {
       Integer value = map.get(key);
       System.out.println(key + " = " + value);
    }
    
    1. 同时遍历key和value:通过for each遍历entrySet()
    for (Map.Entry entry : map.entrySet()) {
        String key = entry.getKey();
        Integer value = entry.getValue();
        System.out.println(key + " = " + value);
    }
    
    1. HashMap
      遍历HashMap的Key时,其顺序是不可预测的。

    要正确使用HashMap,作为key的类必须正确覆写equals()和hashCode()方法

    equals()用到的用于比较的每一个字段,都必须在hashCode()中用于计算;
    equals()中没有使用到的字段,绝不可放在hashCode()中计算。

    int hashCode() {
        return Objects.hash(firstName, lastName, age);
    }
    
    1. TreeMap
      SortedMap在遍历时严格按照Key的顺序遍历,最常用的实现类是TreeMap;

    作为SortedMap的Key必须实现Comparable接口,或者传入Comparator;

    Map map = new TreeMap<>(new Comparator() {
                public int compare(Person p1, Person p2) {
                    return p1.name.compareTo(p2.name);
                }
    });
    
    2. 特点
    1. 实现了接口和实现类相分离,例如,有序表的接口是List,具体的实现类有ArrayList,LinkedList等,
    2. 支持泛型,我们可以限制在一个集合中只能放入同一种数据类型的元素
    3. 访问方式

    Java提供了标准的迭代器模型,即集合类实现java.util.Iterable接口

    for each 循环:List、Set和Queue会迭代每个元素,Map会迭代每个key

    用 迭代器 Iterator 遍历:无需知道集合内部元素是按什么方式存储的

    List list = List.of("Apple", "Orange", "Pear");
    for (String s : list) {
        System.out.println(s);
    }
    

    实际编译:

    for (Iterator it = list.iterator(); it.hasNext(); ) {
         String s = it.next();
         System.out.println(s);
    }
    
    4. 使用Collections

    Collections类提供了一组工具方法来方便使用集合类

    1. 创建集合:
    • 创建List:List emptyList() && List singletonList(T o)
    • 创建Map:Map emptyMap() && Map singletonMap(K key, V value)
    • 创建Set:Set emptySet() && Set singleton(T o)

    返回的集合是不可变集合,无法向其中添加或删除元素

    实际上,使用List.of(T...)更方便,因为它既可以创建空集合,也可以创建单元素集合,还可以创建任意个元素的集合

    1. 创建不可变集合
    List unmodifiableList(List list)
    
    1. 排序 / 洗牌
      排序 / 随机打乱List内部元素的顺序
    其他

    break:跳出自己所在的那一层循环(一层)
    continue: 提前结束本次循环,继续执行下次循环

    转载请注明:文章转载自 www.mshxw.com
    我们一直用心在做
    关于我们 文章归档 网站地图 联系我们

    版权所有 (c)2021-2022 MSHXW.COM

    ICP备案号:晋ICP备2021003244-6号