Java难点学习

Java难点学习

一、next() 与 nextLine() 区别

next():

• 1、一定要读取到有效字符后才可以结束输入。

• 2、对输入有效字符之前遇到的空白，next() 方法会自动将其去掉。

• 3、只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。

• next() 不能得到带有空格的字符串。

nextLine()：

• 1、以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符。

• 2、可以获得空白。

如果要输入 int 或 float 类型的数据，在 Scanner 类中也有支持，但是在输入之前最好先使用 hasNextXxx() 方法进行验证，再使用 nextXxx() 来读取：

二、static关键字

1、静态变量

类的成员变量可以分为以下两种：

1. 静态变量（或称为类变量），指被 static 修饰的成员变量。

2. 实例变量，指没有被 static 修饰的成员变量。

静态变量与实例变量的区别如下：

1）静态变量

• 运行时，Java 虚拟机只为静态变量分配一次内存，在加载类的过程中完成静态变量的内存分配。

• 在类的内部，可以在任何方法内直接访问静态变量。

• 在其他类中，可以通过类名访问该类中的静态变量。

2）实例变量

• 每创建一个实例，Java 虚拟机就会为实例变量分配一次内存。

• 在类的内部，可以在非静态方法中直接访问实例变量。

• 在本类的静态方法或其他类中则需要通过类的实例对象进行访问。

静态变量在类中的作用如下：

• 静态变量可以被类的所有实例共享，因此静态变量可以作为实例之间的共享数据，增加实例之间的交互性。

• 如果类的所有实例都包含一个相同的常量属性，则可以把这个属性定义为静态常量类型，从而节省内存空间。

2、静态方法

与成员变量类似，成员方法也可以分为以下两种：

1. 静态方法（或称为类方法），指被 static 修饰的成员方法。

2. 实例方法，指没有被 static 修饰的成员方法。

静态方法与实例方法的区别如下：

• 静态方法不需要通过它所属的类的任何实例就可以被调用，因此在静态方法中不能使用 this 关键字，也不能直接访问所属类的实例变量和实例方法，但是可以直接访问所属类的静态变量和静态方法。另外，和 this 关键字一样，super 关键字也与类的特定实例相关，所以在静态方法中也不能使用 super 关键字。

• 在实例方法中可以直接访问所属类的静态变量、静态方法、实例变量和实例方法。

3、静态代码块

静态代码块指 Java 类中的 static{ } 代码块，主要用于初始化类，为类的静态变量赋初始值，提升程序性能。

静态代码块的特点如下：

• 静态代码块类似于一个方法，但它不可以存在于任何方法体中。

• 静态代码块可以置于类中的任何地方，类中可以有多个静态初始化块。

• Java 虚拟机在加载类时执行静态代码块，所以很多时候会将一些只需要进行一次的初始化操作都放在 static 代码块中进行。

• 如果类中包含多个静态代码块，则 Java 虚拟机将按它们在类中出现的顺序依次执行它们，每个静态代码块只会被执行一次。

• 静态代码块与静态方法一样，不能直接访问类的实例变量和实例方法，而需要通过类的实例对象来访问。

例：

编写一个 Java 类，在类中定义一个静态变量，然后使用静态代码块修改静态变量的值。最后在 main() 方法中进行测试和输出。

public class StaticCode {
    public static int count = 0;
    {
        count++;
        System.out.println("非静态代码块 count=" + count);       //第三四次执行
    }
    static {
        count++;
        System.out.println("静态代码块1 count=" + count);       //第一次执行
    }
    static {
        count++;
        System.out.println("静态代码块2 count=" + count);      //第二次执行
    }
    public static void main(String[] args) {
        System.out.println("*************** StaticCode1 执行 ***************");
        StaticCode sct1 = new StaticCode();
        System.out.println("*************** StaticCode2 执行 ***************");
        StaticCode sct2 = new StaticCode();
    }
}

如上述示例，为了说明静态代码块只被执行一次，特地添加了非静态代码块作为对比，并在主方法中创建了两个类的实例对象。上述示例的执行结果为：

静态代码块1 count=1
静态代码块2 count=2
*************** StaticCode1 执行 ***************
非静态代码块 count=3
*************** StaticCode2 执行 ***************
非静态代码块 count=4

上述代码中 { } 代码块为非静态代码块，非静态代码块是在创建对象时自动执行的代码，不创建对象不执行该类的非静态代码块。代码域中定义的变量都是局部的，只有域中的代码可以调用。

三、final关键字

使用 final 关键字声明类、变量和方法需要注意以下几点：

• final 用在变量的前面表示变量的值不可以改变，此时该变量可以被称为常量。

• final 用在方法的前面表示方法不可以被重写（子类中如果创建了一个与父类中相同名称、相同返回值类型、相同参数列表的方法，只是方法体中的实现不同，以实现不同于父类的功能，这种方式被称为方法重写，又称为方法覆盖。这里了解即可，教程后面我们会详细讲解）。

• final 用在类的前面表示该类不能有子类，即该类不可以被继承。

四、类的封装

封装的特点：

• 只能通过规定的方法访问数据。

• 隐藏类的实例细节，方便修改和实现。

实现封装的具体步骤如下：

1. 修改属性的可见性来限制对属性的访问，一般设为 private。

2. 为每个属性创建一对赋值（setter）方法和取值（getter）方法，一般设为 public，用于属性的读写。

3. 在赋值和取值方法中，加入属性控制语句（对属性值的合法性进行判断）。

五、Java方法重载（本类）

1、定义

Java允许同一个类中定义多个同名方法，只要它们的形参列表不同即可。如果同一个类中包含了两个或两个以上方法名相同的方法，但形参列表不同，这种情况被称为方法重载

public class OverLoading {
    public void max(int a, int b) {
        // 含有两个int类型参数的方法
        System.out.println(a > b ? a : b);
    }
    public void max(double a, double b) {
        // 含有两个double类型参数的方法
        System.out.println(a > b ? a : b);
    }
    public void max(double a, double b, int c) {
        // 含有两个double类型参数和一个int类型参数的方法
        double max = (double) (a > b ? a : b);
        System.out.println(c > max ? c : max);
    }
    public static void main(String[] args) {
        OverLoading ol = new OverLoading();
        System.out.println("1 与 5 比较，较大的是：");
        ol.max(1, 5);
        System.out.println("5.205 与 5.8 比较，较大的是：");
        ol.max(5.205, 5.8);
        System.out.println("2.15、0.05、58 中，较大的是：");
        ol.max(2.15, 0.05, 58);
    }
}

六、Java方法重写（父类）

1、定义

在子类中如果创建了一个与父类中相同名称、相同返回值类型、相同参数列表的方法，只是方法体中的实现不同，以实现不同于父类的功能，这种方式被称为方法重写

二、注意特点

在重写方法时，需要遵循下面的规则：

• 参数列表必须完全与被重写的方法参数列表相同。

• 返回的类型必须与被重写的方法的返回类型相同。

• 访问权限不能比父类中被重写方法的访问权限更低（public>protected>default>private）。

• 重写方法一定不能抛出新的检査异常或者比被重写方法声明更加宽泛的检査型异常。例如，父类的一个方法声明了一个检査异常 IOException，在重写这个方法时就不能抛出 Exception，只能拋出 IOException 的子类异常，可以抛出非检査异常。

另外还要注意以下几条：

• 重写的方法可以使用 @Override 注解来标识。

• 父类的成员方法只能被它的子类重写。

• 声明为 final 的方法不能被重写。

• 声明为 static 的方法不能被重写，但是能够再次声明。

• 构造方法不能被重写。

• 子类和父类在同一个包中时，子类可以重写父类的所有方法，除了声明为 private 和 final 的方法。

• 子类和父类不在同一个包中时，子类只能重写父类的声明为 public 和 protected 的非 final 方法。

• 如果不能继承一个方法，则不能重写这个方法。

七、Java抽象（abstract）类

抽象方法的 3 个特征如下：

1. 抽象方法没有方法体

2. 抽象方法必须存在于抽象类中

3. 子类重写父类时，必须重写父类所有的抽象方法

注意：在使用 abstract 关键字修饰抽象方法时不能使用 private 修饰，因为抽象方法必须被子类重写，而如果使用了 private 声明，则子类是无法重写的。

抽象类的定义和使用规则如下：

1. 抽象类和抽象方法都要使用 abstract 关键字声明。

2. 如果一个方法被声明为抽象的，那么这个类也必须声明为抽象的。而一个抽象类中，可以有 0~n 个抽象方法，以及 0~n 个具体方法。

3. 抽象类不能实例化，也就是不能使用 new 关键字创建对象。

八、Java接口（Interface）

1、接口的限制

• 具有 public 访问控制符的接口，允许任何类使用；没有指定 public 的接口，其访问将局限于所属的包。

• 方法的声明不需要其他修饰符，在接口中声明的方法，将隐式地声明为公有的（public）和抽象的（abstract）。

• 在 Java 接口中声明的变量其实都是常量，接口中的变量声明，将隐式地声明为 public、static 和 final，即常量，所以接口中定义的变量必须初始化。

• 接口没有构造方法，不能被实例化。

2、实现接口需要注意的几点

• 实现接口与继承父类相似，一样可以获得所实现接口里定义的常量和方法。如果一个类需要实现多个接口，则多个接口之间以逗号分隔。

• 一个类可以继承一个父类，并同时实现多个接口，implements 部分必须放在 extends 部分之后。

• 一个类实现了一个或多个接口之后，这个类必须完全实现这些接口里所定义的全部抽象方法（也就是重写这些抽象方法）；否则，该类将保留从父接口那里继承到的抽象方法，该类也必须定义成抽象类。

九、Java异常处理

为了能够及时有效地处理程序中的运行错误，Java 专门引入了异常类。在 Java 中所有异常类型都是内置类 java.lang.Throwable 类的子类，即 Throwable 位于异常类层次结构的顶层。Throwable 类下有两个异常分支 Exception 和 Error，如下图所示。

Throwable 类是所有异常和错误的超类，下面有 Error 和 Exception 两个子类分别表示错误和异常。其中异常类 Exception 又分为运行时异常和非运行时异常，这两种异常有很大的区别，也称为不检查异常（Unchecked Exception）和检查异常（Checked Exception）。

• Exception 类用于用户程序可能出现的异常情况，它也是用来创建自定义异常类型类的类。

• Error 定义了在通常环境下不希望被程序捕获的异常。一般指的是 JVM 错误，如堆栈溢出。

本节不讨论关于 Error 类型的异常处理，因为它们通常是灾难性的致命错误，不是程序可以控制的。接下来将讨论 Exception 类型的异常处理。

1、运行时异常

是 RuntimeException 类及其子类异常，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。这些异常一般由程序逻辑错误引起，程序应该从逻辑角度尽可能避免这类异常的发生。

例如：NullPointerException、IndexOutOfBoundsException 等

2、编译时异常

指 RuntimeException 以外的异常，类型上都属于 Exception 类及其子类。从程序语法角度讲是必须进行处理的异常，如果不处理，程序就不能编译通过。

例如：IOException、ClassNotFoundException、FileNotFoundException等。

Java的异常处理通过 5 个关键字来实现：try、catch、throw、throws 和 finally。try catch 语句用于捕获并处理异常，finally 语句用于在任何情况下（除特殊情况外）都必须执行的代码，throw 语句用于拋出异常，throws 语句用于声明可能会出现的异常。

本节先主要介绍异常处理的机制及基本的语句结构。

Java 的异常处理机制提供了一种结构性和控制性的方式来处理程序执行期间发生的事件。异常处理的机制如下：

• 在方法中用 try catch 语句捕获并处理异常，catch 语句可以有多个，用来匹配多个异常。

• 对于处理不了的异常或者要转型的异常，在方法的声明处通过 throws 语句拋出异常，即由上层的调用方法来处理。

以下代码是异常处理程序的基本结构：

try {
    逻辑程序块
} catch(ExceptionType1 e) {
    处理代码块1
} catch (ExceptionType2 e) {
    处理代码块2
    throw(e);    // 再抛出这个"异常"
} finally {
    释放资源代码块
}

十、Java集合（重点）

1、Collection接口

Collection 接口是 List、Set 和 Queue 接口的父接口，通常情况下不被直接使用。

常用方法：

例如：

      ArrayList<Integer> array=new ArrayList<>();
        array.add(5);
        array.add(520);
        array.add(1314);
        Iterator iterator=array.iterator();
        while(iterator.hasNext()){
            System.out.print(iterator.next()+" ");
        }
​
        array.remove(1);
​
        System.out.println();
        System.out.println("---------------------");
        for(Integer n:array){
            System.out.print(n+" ");
        }

array.add(123) 向集合中添加一个元素，如果集合对象被添加操作改变了，则返回 true。

array.remove(index:下标) 从集合中删除一个指定元素，当集合中包含了一个或多个元素 o 时，该方法只删除第一个符合条件的元素，该方法将返回 true。

array.size(); 返回集合中元素的个数。

2、Java List集合

List集合特点：有序，有索引，元素可以重复的集合体系

1）ArrayList集合

特点：底层是动态数组，

优点：查询快，增删慢，效率高；

缺点：线程不安全

常用方法

    public static void main(String[] args) {
        ArrayList<Integer> array=new ArrayList<Integer>();
        array.add(5);
        array.add(520);
        array.add(1314);
​
//      迭代器遍历
        Iterator iterator=array.iterator();
        System.out.println("-----------动物信息-------------");
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
        
​
//      获取此集合中指定索引位置的元素
        System.out.println(array.get(1));
​
    }

array.add(123) 向集合中添加一个元素，如果集合对象被添加操作改变了，则返回 true。

array.remove(index:下标) 从集合中删除一个指定元素，当集合中包含了一个或多个元素 o 时，该方法只删除第一个符合条件的元素，该方法将返回 true。

array.size(); 返回集合中元素的个数。

array.get(index:下标) 获取此集合中指定索引位置的元素。

2）LinkedList集合

LinkedList集合的底层实现是一个链表的数据结构，但是它同样也是一个有序集合，也有索引值。

优点：增删快，效率高

缺点：查询慢，线程不安全

链表数据结构:是通过结点来链接组成的一种数据结构，每个结点存储地址值，值，下一个节点地址值这三个。这样形成每个结点都和前后结点有互相关系。当你插入一个结点的时候，只需要改动两个结点:告诉前结点，你的下一个结点现在是我了，告诉插入的结点，你的下一个结点是被你占了位置的结点。

特有的方法（其他方法与ArrayList相同）

方法名称	说明
void addFirst(E e)	将指定元素添加到此集合的开头
void addLast(E e)	将指定元素添加到此集合的末尾
E getFirst()	返回此集合的第一个元素
E getLast()	返回此集合的最后一个元素
E removeFirst()	删除此集合中的第一个元素
E removeLast()	删除此集合中的最后一个元素

ArrayList和LinkedList的区别 (重中之重)

• ArrayList 与 LinkedList 都是 List 接口的实现类，因此都实现了 List 的所有未实现的方法，只是实现的方式有所不同。

• ArrayList 是基于动态数组数据结构的实现，访问元素速度优于 LinkedList。LinkedList 是基于链表数据结构的实现，占用的内存空间比较大，但在批量插入或删除数据时优于 ArrayList。

• 对于快速访问对象的需求，使用 ArrayList 实现执行效率上会比较好。需要频繁向集合中插入和删除元素时，使用 LinkedList 类比 ArrayList 类效果高。

• 不同的结构对应于不同的算法，有的考虑节省占用空间，有的考虑提高运行效率，对于程序员而言，它们就像是“熊掌”和“鱼肉”，不可兼得。高运行速度往往是以牺牲空间为代价的，而节省占用空间往往是以牺牲运行速度为代价的。

3）Vector集合

底层是数组

优点：查询快，线程安全

缺点：增删慢，效率低

3、Java set集合

特点：无序，无索引，元素唯一的接口。会重写equals语句

应用场景：元素去重;根据boolean add(E e)判断是否添加成功。同样的元素添加进去会返回false;

例：字符串去重

    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        System.out.println("请输入字符串");
        String str=input.nextLine();
        HashSet<Character> strs=new HashSet<>();
        for(int i=0;i<str.length();i++){
            Character s=str.charAt(i);           //将字符串str中的每个字符拆分给s
            strs.add(s);
        }
​
        Iterator iterator=strs.iterator();
        while(iterator.hasNext()){
            System.out.print(iterator.next());
        }
    }