java基础复习

面对对象

2.7、final关键字

final关键字代表最终、不可改变的。
常见四种用法:

• 可以用来修饰一个类
• 可以用来修饰一个方法
• 还可以用来修饰一个局部变量
• 还可以用来修饰一个成员变量

当final修饰一个类的时候，其格式：

public final class 类名称(){
    //..............
}

含义:当前这个类不能有任何的子类。(太监类)

• 注意:一个类如果是final的，那么其中所有的成员方法都无法进行覆盖重写(因为没儿子)

当final修饰一个方法的时候，其格式：

修饰符 final 返回值类型 方法名称（参数列表）{
    //方法体
}

当final关键字用来修饰一个方法的时候，这个方法就是最终方法，也就是不能被覆盖重写。

• 注意:对于类、方法来说， abstract关键字和final关键字不能同时使用，因为矛盾。

当final修饰局部变量的时候

• 对于基本类型来说，不可变说的是变量当中的数据不可改变

• 对于引用类型来说，不可变说的是变量当中的地址值不可改变

当final修饰成员变量的时候

对于成员变量来说，如果使用final关键字修饰，那么这个变量也照样是不可变。

1、由于成员变量具有默认值，所以用了final之后必须手动赋值，不会再给默认值了。

2、对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值。二者选其一。

3、必须保证类当中所有重载的构造方法，都最终会对final的成员变量进行赋值。

2.8、四种修饰符

2.9、内部类

分类：
1、成员内部类
2、局部内部类（包含匿名内部类)

成员内部类的定义格式：

修饰符 class 外部类名称{
    修饰符 class 内部类名称{
        //.............
    }
    //.............
}

注意：内用外，随意访问; 外用内，需要内部类对象。

如何使用成员内部类

• 间接方式:在外部类的方法当中，使用内部类，然后main只是调用外部类的方法。
• 直接方式，公式:
  • 外部类名称.内部类名称 对象名 = new 外部类名称() .new内部类名称();

内部类同名变量的访问

public class Outer {
    int num = 10; //外部类的成员变量
    public class Inter{
        int num = 20; //内部类的成员变量
        public void methodInner(){
            int num = 30; //内部类方法的局部变量
            System.out.println(num);//局部变量，就近原则
            System.out.println(this.num);//内部类的成员变量
            System.out.println(Outer.this.num);//外部类的成员变量
        }
    }
}

局部内部类的定义格式：

修饰符 class 外部类名称{
    修饰符 返回值类型 外部类方法名（参数列表）{
        class 内部类名称{
             //.............
        }
    }   
}

小节一下类的权限修饰符：

• public > protected (default) > private

定义一个类的时候，权限修饰符规则:

• 外部类:public / ( defauLt)
• 成员内部类:public / protected / ( default) / private
• 局部内部类，什么都不能写

局部内部类的使用方法为：在外部类new内部类，调用方法

匿名内部类

如果接口的实现类（或者是父类的子类)只需要使用唯一的一次。
那么这种情况下就可以省略掉该类的定义，而改为使用【匿名内部类】。

格式：

接口名称  对象名  =  new  接口名称（）{
    //覆盖重写所有抽象方法
};

注意事项：

• 匿名内部类,在【创建对象】的时候，只能使用唯一 一次。
• 如果希望多次创建对象，而且类的内容一样的话，那么就必须使用单独定义的实现类了。
• 匿名对象,在【调用方法】的时候,只能调用唯一 —次。
• 如果希望同一个对象，调用多次方法,那么必须给对象起个名字。
• 匿名内部类是省略了【实现类/子类名称】，但是匿名对象是省略了【对象名称】
• 强调: 匿名内部类和匿名对象不是一回事!!!

3.0、Collection集合概述

集合概述

• 集合:集合是java中提供的一种容器，可以用来存储多个数据。

集合和数组既然都是容器，它们有啥区别呢?

• 数组的长度是固定的。集合的长度是可变的。
• 数组中存储的是同一类型的元素，可以存储基本数据类型值。集合存储的都是对象。而且对象的类型可以不一致。在开发中一般当对象多的时候，使用集合进行存储。

1、学习顶层:学习顶层接口/抽象类中共性的方法，所有的子类都可以使用
⒉、使用底层:顶层不是接口就是抽象类,无法创建对象使用,需要使用底层的子类创建对象使用

常用功能

• java.util.collection接口

  • 所有单列集合的最顶层的接口,里边定义了所有单列集合共性的方法,任意的单列集合都可以使用collection接口中的方法

• public boolean add(E e): 把给定的对象添加到当前集合中。

• public void clear(): 清空集合中所有的元素。

• public boolean remove(E e): 把给定的对象在当前集合中删除。

• public boolean contains(E e): 判断当前集合中是否包含给定的对象。

• public boolean isEmpty(): 判断当前集合是否为空。

• public int size(): 返回集合中元素的个数。

• public object[] toArray(): 把集合中的元素，存储到数组中。

public class DemoCollection {
    public static void main(String[] args) {
        Collection<String> coll = new ArrayList<>();
        System.out.println(coll);//[]

        boolean a = coll.add("张三");
        System.out.println("a:"+a);//a:true
        coll.add("李四");
        coll.add("王五");
        coll.add("赵六");
        coll.add("田七");
        System.out.println(coll);//[张三, 李四, 王五, 赵六, 田七]

        boolean b = coll.remove("王五");//删除指定元素
        System.out.println("b:"+b);//b:true
        boolean c = coll.remove("田七");
        System.out.println("c:"+c);//c:true
        System.out.println(coll);//[张三, 李四, 赵六]

        boolean d = coll.contains("张三");
        System.out.println("d:"+d);//d:true

        boolean e = coll.isEmpty();//判断是否为空
        System.out.println("e:"+e);//e:false

        Object[] obj = coll.toArray();//把集合中元素存到数组中
        for (int i = 0; i < obj.length; i++) {
            System.out.println(obj[i]);
        }

        int size = coll.size();//返回个数
        System.out.println("元素个数为："+size);//元素个数为：3

        coll.clear();
        System.out.println(coll);//[]       清空元素，但是集合还在


    }
}

3.1、iterator接口（迭代器）

在程序开发中，经常需要遍历集合中的所有元素。针对这种需求，JDK专门提供了一个接口 java.util.Iterator 。Iterator接口也是Java集合中的一员，但它与collection、Map 接口有所不同，collection接口与Map接口主要用于存储元素，而Iterator主要用于迭代访问(即遍历) collection 中的元素，因此Iterator对象也被称为迭代器。

• 迭代: 即Collection集合元素的通用获取方式。在取元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续在判断，如果还有就再取出出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。

有两个常用的方法

• boolean hasNext() 如果仍有元素可以迭代，则返回trueo
  • 判断集合中还有没有下一个元素,有就返回true,没有就返回false
• E next(）返回迭代的下一个元素。
  • 取出集合中的下一个元素

Iterator迭代器,是一个接口,我们无法直接使用,需要使用Iterator接口的实现类对象,获取实现类的方式比较特殊
collection接口中有一个方法,叫iterator()，这个方法返回的就是迭代器的实现类对象
Iterator iterator(）返回在此 collection的元素上进行迭代的迭代器。

迭代器的使用步骤(重点):

1、使用集合中的方法iterator()获取迭代器的实现类对象,使用Iterator接口接收(多态)

2、使用Iterator接口中的方法hasNext判断还有没有下一个元素

3、使用Iterator接口中的方法next取出集合中的下一个元素

public class DemoIterator {
    public static void main(String[] args) {
        Collection<String> coll = new ArrayList<>();
        coll.add("吕布");
        coll.add("赵云");
        coll.add("典韦");
        coll.add("张飞");

        //Iterator<E>接口也是有泛型的,迭代器的泛型跟着集合走,集合是什么泛型,迭代器就是什么泛型
        Iterator<String> it = coll.iterator();
        while (it.hasNext()){
            String a = it.next();
            System.out.println(a);
        }
    }
}

3.2、增强For循环

增强for循环(也称for each循环)是JDK1.5以后出来的一个高级for循环，专门用来遍历数组和集合的。它的内部原理其实是个lterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。

格式：

for(元素的数据类型  变量 ： Collection集合or数组){
    //操作代码
}

public class DemoForEach {
    public static void main(String[] args) {
        demo1();
        demo2();
    }
    public static void demo1(){
        int[] array = {1,2,3,4,5};
        for (int i : array){
            System.out.println(i);
        }
    }
    public static void demo2(){
        ArrayList<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        for (String s : list){
            System.out.println(s);
        }
    }
}

3.3、范型

泛型是一种未知的数据类型，当我们不知道使用什么数据类型的时候可以使用泛型

• 泛型也可以看出是一个变量，用来接收数据类型

ArrayList集合在定义的时候不知道集合中都会存储什么类型的数据,所以类型使用泛型

• E：未知的数据类型

public class ArrayList<E>{
    public boolean add(E e){}
    public E get(int index){}
}

创建集合对象的时候就会确定泛型的数据类型

ArrayList<String> list = new ArrayList<>();

public class ArrayList<String>{
    public boolean add(String e){}
    public String get(int index){}
}

创建集合对象,使用泛型好处:

• 避免了类型转换的麻烦,存储的是什么类型,取出的就是什么类型

• 把运行期异常(代码运行之后会抛出的异常),提升到了编译期(写代码的时候会报错)

弊端:

泛型是什么类型,只能存储什么类型的数据

定义和使用含有范型的类

public class Class<E> {
    private E name;

    public E getName() {
        return name;
    }

    public void setName(E name) {
        this.name = name;
    }
}

public class DemoClass {
    public static void main(String[] args) {
        Class<String> Sc = new Class<>();
        Sc.setName("张三");
        String name = Sc.getName();
        System.out.println(name);

        Class<Integer> Sc1 = new Class<>();
        Sc1.setName(1);
        Integer name1 = Sc1.getName();
        System.out.println(name1);
    }
}

定义和使用含有范型的方法

public class Demo1 {
    //定义一个范型的方法
    public <E> void method(E e){
        System.out.println(e);
    }
    //定义一个静态的范型方法
    public static <M> void method1(M m){
        System.out.println(m);
    }
}

public class DemoGenericMethod {
    public static void main(String[] args) {
        Demo1 demo1 = new Demo1();
        //传递的是什么类型，范型就是什么类型
        demo1.method("张飞");
        demo1.method(1);
        demo1.method(3.4);
        demo1.method(true);

        Demo1.method1("静态方法不推荐创建对象使用");
    }
}