JavaSE（总结）

第一部分： 基础知识

第二部分： 面向对象

• 封装

  • 类：对一类事物抽象所得到的概念

  • 对象：一个具体的事物

  • 构造函数：

    • 不能有返回值

    • 方法名与类名相同

    • 可以有多个

    • 默认生成无参方法体无返回值的构造函数

    • 自己一旦定义，编译器将不再生成默认的构造函数

    • 生成一个类对象时，能且只能调用其中的一个构造函数

  • static：静态的属于整个类本身，非静态的属于对象

    • 非私有的才能通过类名访问A.i；

    • 凡是static修饰的成员都是静态成员，静态成员都是属于类的，

    • 非静态的可以访问静态成员，而静态的不可以访问非静态的

    • 通过类名只能访问一个类中非私有静态成员

    • 私有静态成员也不可以通过对象名访问

     class A{
         static int i;
         int j;
         public static void g(){
             System.out.println("我真帅！！");
         }
         public void f(){
             System.out.println(i*2);
         }
     }
     public class demo01 {
         public static void main(String[] args) {
             A.g();
         }
     }

  • this：非静态方法默认都有一个this指针，this代表正在调用本方法的对象。

  • final

    • 修饰类

      • 该类不能被继承

    • 修饰方法

      • 该方法可以被继承，但不可以被重写

    • 修饰属性

      • 表示该属性能且只能被赋一次值，赋值方式有两种，并且只能选择其中的一种来赋值：

        • 定义的同时显示的初始化

         class A{
             private final int i = 10;
         }

        • 构造函数中初始化

             
             class A{
             private final int i;
             public A(int j) {
                 this.i = j;
             }
         }
         ​

  • 函数的重载

    • 同名不同参

    • 返回值不能作为是否构成函数重载的依据

• 继承

  • 定义：子类继承了父类的成员

  • 注意的问题：

    • 非私有成员才可以被子类继承

    • 重写：

      • 重写方法必须和被重写方法具有相同的方法名称、参数列表、返回值类型

      • 重写方法的访问权限不能小于被重写方法

• 多态

  • 定义：统一代码可以随上下文的不同而执行不同的操作，俗称多态

    • 即：一个父类的引用它既可以指向父类对象也可以指向子类对象，它可以根据当前时刻指向的不同，自动调用不同对象的方法。

  • 注意事项：

    • 通过父类的引用只能访问子类从父类继承过来的成员

      •  ​
         class A{
             public void f() {
             }
         }
         class B extends A{
             public void f(A aa){
                 aa.f();
             }
             public void g() {
             }
         }
         public class demo01 {
             public static void main(String[] args) {
                 A aa = new B();
                 aa.f();
                 // error aa.g();
             }
         }

    • 只有在父类的引用本身自己想的就是一个子类对象时，我们才可以把父类的引用强制转化成子类的引用

       ​
       class A{
           public void f() {
           }
       }
       class B extends A{
           public void f(A aa){
               aa.f();
           }
           public void g() {
           }
       }
       public class demo01 {
           public static void main(String[] args) {
               A aa = new B();
               B bb = new B();
               aa = bb;
              bb = (B)aa;
               aa.f();
               // error aa.g();
           }
       }
       ​

  • 相关知识：

    • 抽象类：

      • 一个抽象类通常都含有抽象方法

      • 只重写了抽象类的部分抽象方法的类也必须别标记为abstract

      • 不可以定义抽象类对象，但是抽象类可以实现多态

    • 接口

      • 接口中的方法都是public abstract

      • 不可以定义接口对象，但接口却可以实现多态。重写接口方法时public不能省

      • 举例：

        • 线程的创建

        • 事件的处理

        • 容器的组织方式

        • serializable接口

第三部分：高级部分

• 异常

  • 定义：运行时的错误

• 分类：

  • 无法处理的错误

  • 可以处理的异常

    • 必须处理的异常

      • 是Exception的子类但不是RuntimeException的异常

    • 可处理可不处理的异常

      • 是RuntimeException的子类

    • 注意问题：

      • finally{......} 一定会执行

      • 先捕获子类异常，再捕获父类异常，顺序不可颠倒

      • 重写方法抛出异常的范围不能大于重写方法抛出异常的范围

      • 假设F方法抛出了A异常，则F方法有两种方式处理A异常。

        • throws A

             public void f() throws A{
                   throw new Exception();
               }

        • try {....}catch(){.....}

               public void f(){
                   try {
                       throw new Exception();
                   } catch (Exception e) {
                       e.printStackTrace();
                   }
               }

• 线程

  • 定义：一个程序运行时的不同执行路径

  • 创建线程的方式：

    • 继承Thread类

    • 实现了Runnable接口

  • 线程的同步

    • 多个线程操作同一资源，并且要求这些操作中的若干个操作不能被中断，这时就需要考虑线程同步的问题。

    • 线程同步是通过synchronized实现的

    • synchronized可以修饰两种：

      • 代码块：

      • 方法（默认所定的是this）

    • 实例：买票

  • 线程的通信

    • 有时多个线程只有彼此相互协作才可以完成某个功能，这时就需要线程的通信

    • 实现方式：wai 和notify（）/notifyAll（）；

    • 示例：生产消费

• 包

  • 包的生产与运行：

    • package语句必须是第一条语句

    • 类名是包名和类名的组合

    • 只有在整个包的最上层目录才可以运行

  • 同包：

  • 不同包的相互访问：

  • jar包的生成与jar包的使用：

    • 普通jar包的生成

      • jar - cvf 要生成的jar包的名字jar.*

    • 可运行的jar包的生成：

      • jar cvfm要生成jar包的名字.jar 1 .txt *

• GUI

  • 容器和组件的关系：

    • 容器是组件，但组件不一定是容器

  • 常见的布局管理器：

    • BorderLayout--Fraem

    • FlowLayout -- Panel

    • GridLayout

  • 事件模型：必须要明白那些操作时编译器自动完成的，那些操作是程序员手动处理的。

  • 程序员只需要做两件事：告诉事件源可以产生那些事件，设计好可以处理这些事件的事件监听器

  • 内部类：

    • 在一个类内部定义的一个类叫做内部类

    • 内部类的方法可以访问外部类的所有成员

    • 外部类的方法不可以直接访问内部类的任何成员

    • 一定要明白产生内部类的原因

      • 如果一个类A要使用B类所有的成员，并且A类不需要被除B以外的其它类访问，则我们可以把A定义成B的内部类

      • 因此几乎不存在直接生成内部类对象的问题

      • 因此几乎不存在外部类需要访问内部类成员的问题

  • 匿名类：

    • 匿名类是内部类的一种极端表现形式

    • 匿名类可以访问外部类的所有成员和包裹本匿名类方法中的final类型的局部变量

• IO

  • 定义：

    • 如果一个类是用来完成程序和设备之间的数据传输，则这个类有一定的称谓叫做流。

  • 流和类的关系：流一定是类，但类不一定是流

  • 分类：

  输出流	输入流
  字符流	字节流
  包裹流	原始流

  • 常用流的介绍：

    • 四大基本抽象流：

      • InputStream	OutputStream
        Writer``	Reader

      • 字节流与字符流的区别：

        • 字节流可以处理所有格式的文件

        • 字符流只可以处理文本格式的文件

    • 文件流：

      • FileInputStream	FileOutputStream
        FileReader	FileWriter

    • 缓冲流

      • 缓冲流可以提高数据传输的速度

      • BufferedInputStream	BufferedOutputStream
        BufferedReader	BufferedWriter

    • 转化流：

      • 例子：

        • 编程实现把用户从键盘输入的字符保存到一个String对象中

    • 数据流

      • 数据类可以把基本数据类型的二进制直接读入或写出

      • 例子：

        • 编程实现将long类型数据写入byte数组然后再从byte数组中把该数据读出来

    • Print流

      • Print流可以把基本类型数据格式化后的字符串输出

      • 例子：

        • 编程实现把键盘输入的数据写入A文件如果输入有误则把出错信息写入B文件。

    • Object流

      • Object流可以把一个对象直接写入或者读出

• 容器

  • 定义：如果一个类是专门用来存放其他对象的，则这个类有另外一个特殊的词叫做容器

  • 容器和类的关系

    • 容器一定是类，但类不一定是容器

  • Collection接口

    • Set接口

      • 无序，不允许重复

      • 实现类：

        • TreeSet HashSet

    • List接口

      • 有序，允许重复

      • 实现类：

        • ArrayList LinkedList

    • Map接口

      • 定义

        • 既保存数据本身，也保存数据主键的一种接口

      • 实现类：

        • HashMap TreeMap

        • `hashCode（）和equals（）方法

    • Collections类

      • 该类提供了对Collection接口实现类的排序，倒置、查找等功能。

    • Comparable 接口

      • 通过该接口的方法可以制定出对象之间比较的标准

      • 凡是需要进行对象的比较排序的场合均可以考虑实现该接口

    • Iterator接口

      • 利用该接口提供的方法可以遍历所有容器中的元素