菜鸡的Java复习

Java基础

  • Java SE(Standard Edition) 标准版本。
    Java EE (Enterprise Edition) 企业版本
    Java ME(Micro Edition) 微型版本。

  • 常用概念

    • JDK:Java开发工具包
    • JVM:Java虚拟机
    • JRE:Java运行环境
  • JDK目录构成

    jdk1.8.0
    |-bin
    |- java.exe
    |- javac.exe
    |- javap.exe
    |- javah.exe
    |- javadoc.exe
    |-lib
    |- tools.jar
    |- dt.jar
    |-jre
    |- bin
    |- java.exe
    |- java.dll
    |- awt.dll
    |- server
    |- jvm.dll
    |- lib
    |-rt.jar
    |-ext
    |-security
  • 编译、执行命令

    • javac xxx.java
    • java 类名(不加任何后缀)

Java语言基础

标识符定义规则

  1. 标识符由26个英文字符大小写(a~z,A~Z)、数字(0~9)、下划线(_)和美元符号($)组成。

  2. 不能以数字开头,不能是关键字

  3. 严格区分大小写

  4. 标识符的可以为任意长度

  5. 包名 多个单词组成时所有字母小写

  6. 类名和接口 多个单词组成时所有单词的首字母大写

  7. 变量名和函数名 多个单词组成时第一个单词首字母小写,其他单词首字母大写

  8. 常量名 多个单词组成时,字母全部大写,多个单词之间使用_分隔

  9. 虽然Java取消了goto,const这些关键字,但不能用来作为标识符使用

整性

  • byte: 一个字节、8位,取值范围:$-127 \sim 128$,默认值是 0

  • short: 两个字节、16位,取值范围:$-32768 \sim 32767$,默认值是 0

  • int: 四个字节、32位,取值范围:$-2^{31} \sim 2^{31}$-1,默认值是 0

  • long: 八个字节、64位,取值范围:$-2^{63}\sim 2^{63}$-1,默认值是 0L
    如果整性后没有字母默认是int

浮点型

  • float: 单精度型,四个字节,32位,默认值是 0.0f

  • double: 双精度型,八个字节,64位,默认值是 0.0d
    如果浮点数后没有字母,默认是double

字符型

  • char: 两个字节、16位,取值范围:0~65535

布尔型

  • boolen 一个字节,8位,默认值是false

基本数据类型相互转换

  • byte short char 进行运算时转换成 int

  • 其余情况转换成字节占用最高的

Java结构化语句

分支语句

  • switch(expression)语句中,expression的数据类型只能是byte short char int

  • switch 结构中,每一个case后必须跟上break,否则会继续执行后面的case语句,直到遇到break或者switch结束

循环语句

  • for类型循环多用于数值型循环

  • break语句可以用在循环体或者switch语句中,表示跳出当前循环体或者switch


面向对象基础

  • Java是一门面向对象编程语言,Java代码编译后不能直接运行,它是解释运行在JVM上的,所以它是解释型

    面向对象编程的三大特性

    • 封装、继承、多态

    对象和类的关系

    • 类是对象的抽象,对象是类的实例化

    类的定义(属性、构造方法、方法)

    类的定义需要使用class关键字,可能还会指定继承自某一个类,或者需要实现某些接口

    • 一个类可以包含如下变量

      • 类变量
        类变量也声明在类中,方法体之外,但必须声明为 static 类型

      • 成员变量(属性)

        • 成员变量是定义在类中,方法体之外的变量。这种变量在创建对象的时候实例化。

        • 属性不仅可以使简单类型变量,也可以是一个对象

        • 成员变量可以被类中方法、构造方法和特定类的语句块访问。

      • 局部变量
        在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中,方法结束后,变量就会自动销毁。

        所有的变量在使用前都必须进行初始化,方法中的变量必须显示初始化。

    • 构造方法
      每个类都有构造方法。如果没有显式地为类定义构造方法,Java 编译器将会为该类提供一个默认构造方法。

      • 构造方法名与类名相同
      • 构造方法没有返回值
      • 在创建新对象时,系统自动的调用该类的构造方法
      • 一个类可以有多个构造方法
      • 如果显示定义了任意一个构造方法,那么默认的无参构造方法不会生成
    • 方法
      方法是语句的集合,它们在一起执行一个功能。
      方法包括修饰符、返回值类型、方法名、参数类型、方法体

    实例化对象

    new创建一个对象S时进行的步骤:

    1. 加载.class文件
    2. 在栈内存为S申请空间
    3. 在堆内存为对象申请空间
    4. 对成员变量进行默认初始化
    5. 对成员变量进行显示初始化
    6. 执行构造方法

    thissuper

    • this是自身的一个对象,代表对象本身,可以理解为指向自己的一个指针

    • super可以理解为是指向自己超(父)类对象的一个指针,指的是离自己最近的一个父类

    static

    • 创建一块静态内存区,在静态内存区为静态属性分配空间
    • 当JVM加载类时,就会执行

    static的使用方法

    • 如果想在不创建对象的情况下调用某个方法,则可以通过将这个方法设置为static来实现。
    • 在静态方法中不可以使用this关键字
    • 静态方法可以直接通过类名调用,任何的实例也都可以调用
    • 不能直接访问所属类的实例变量和实例方法

    访问控制符

    访问控制

    继承的意义和使用方法

    Java中类之间只允许单一继承

    使用方法

    1. 在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的,extends 只能继承一个类,一般形式如
    class 父类 {
    }
    class 子类 extends 父类 {
    }
    1. 或者使用implements关键字,让当前类继承某个或多个接口
    public interface A {
    public void eat();
    public void sleep();
    }
    public interface B {
    public void show();
    }
    public class C implements A,B {
    }
    1. 通过内部类间接实现多继承
      如果父类为抽象类或者具体类,那么就仅能通过内部类来实现多重继承,见下
    class Father {
    public int str(){
    return 2;
    }
    }
    class Mother {
    public int can(){
    return 2;
    }
    }
    class Son {
    class Father_1 extends Father{
    public int str(){
    return super.str() + 1;
    }
    }
    class Mother_1 extends Mother{
    public int can(){
    return super.can() - 2;
    }
    }
    public int get(){
    return new Father_1().str();
    }
    public int getcan(){
    return new Mother_1().can();
    }
    }
    public class Outer {
    public static void main(String[] args) {
    Son son = new Son();
    System.out.println( son.get());
    System.out.println( son.getcan());
    }
    }

    继承类型

    注:上图中所描述的不支持多继承指的的类之间

    继承的特性

    • 子类拥有父类非 private 的属性、方法

    • 子类可以拥有自己的属性和方法,即子类可以对父类进行扩展

    • 子类可以用自己的方式实现父类的方法

    • 提高了类之间的耦合性(耦合度高就会造成代码之间的联系越紧密,代码独立性越差)

    • 当一个类没有继承的两个关键字extendsimplements时,则默认继承object

    多态性

    多态:同一个行为具有多个不同表现形式或形态的能力

    • 多态存在的三个必要条件
      • 继承
      • 重写
      • 父类引用指向子类对象:Parent p = new Child();

    finalabstract

    final

    final 修饰类则表示这个类是无法被继承的类, 也就是在类族树中最底层的类, 如果你不想该类被派生出子类, 那么可以用final 来修饰这个类

    • private 方法会被认为是final方法
    • final 变量必须赋值
    • final 修饰符通常和 static 修饰符一起使用来创建类常量。

    abstract

    abstract 的中文意思是抽象的, 就是这个东西不存在, 也就是不能被直接实例化

    • abstract 可以修饰类,类的方法
    • abstract 有冲突的不能共存的修饰符: private final static
    abstract 修饰类
    • 抽象类不能直接实例化
    • 类中如果有一个或多个abstract方法,则该类必须声明为abstract
    • 抽象类中的方法不一定都是abstract方法,它还可以包含一个或者多个具体的方法
    • 抽象类中的抽象方法要被使用,必须由子类复写起所有的抽象方法后,建立子类对象调用
    • 如果子类只覆盖了部分抽象方法,那么该子类还是一个抽象类
    abstract 修饰类方法
    • 抽象方法不能包含函数体, 而且要用分号结尾
    • 不能用private 修饰抽象方法
    • 不能用static 修饰抽象方法

    接口

    是抽象方法的集合,接口通常以interface来声明。一个类通过继承接口的方式,从而来继承接口的抽象方法

    接口的声明

    [可见度] interface 接口名称 [extends 其他的接口名] {
    // 声明变量
    // 抽象方法
    }

    接口的实现

    当类实现接口的时候,类要实现接口中所有的方法。否则,类必须声明为抽象的类。

    ...implements 接口名称[, 其他接口名称, 其他接口名称..., ...] ...

    比如:

    interface Animal {//接口
    public void eat();
    public void travel();
    }

    public class MammalInt implements Animal{//实现
    public void eat(){
    System.out.println("Mammal eats");
    }
    public void travel(){
    System.out.println("Mammal travels");
    }
    public int noOfLegs(){
    return 0;
    }
    public static void main(String args[]){
    MammalInt m = new MammalInt();
    m.eat();
    m.travel();
    }
    }

    注意:

    • 重写接口中声明的方法时:

      • 重写方法时要保持一致的方法名,并且应该保持相同或者相兼容的返回值类型。
      • 如果实现接口的类是抽象类,那么就没必要实现该接口的方法
    • 实现接口时

      • 一个类可以同时实现多个接口

    接口的继承

    一个接口能继承另一个接口,和类之间的继承方式比较相似。接口的继承使用 extends 关键字,子接口继承父接口的方法。

    public interface Sports
    {
    public void setHomeTeam(String name);
    public void setVisitingTeam(String name);
    }

    public interface Football extends Sports
    {
    public void homeTeamScored(int points);
    public void visitingTeamScored(int points);
    public void endOfQuarter(int quarter);
    }

    public interface Hockey extends Sports
    {
    public void homeGoalScored();
    public void visitingGoalScored();
    public void endOfPeriod(int period);
    public void overtimePeriod(int ot);
    }

    接口的多继承

    在Java中,类的多继承是不合法,但接口允许多继承。

    public interface Hockey extends Sports, Event

    Java 包(package)

    Java 使用包package这种机制是为了防止命名冲突,访问控制,提供搜索和定位类class、接口、枚举enumerations和注释annotation等。

    创建包

    package pkg1[.pkg2[.pkg3…]];

    引入包

    为了能够使用某一个包的成员,我们需要在Java程序中明确导入该包。使用 import可完成此功能。

    import package1[.package2…].(classname|*);

Java常用类

Sting类

创建String字符串

  1. 最简单创建字符串的方式
String str = "Codgi";
  1. 利用构造函数创建字符串
String str = new string("Codgi");

注意:如果是采用直接创建的方法,则存储空间是分配在公共池中(地址相同),若采用new分配则分配在堆上

String常用的方法

  • int length() 获取字符串长度
    注意:对于字符串而言,获取长度是方法,而对于数组而言,获取长度是通过属性

  • String concat(String str) 连接两个字符串

  • char charAt(int index) 返回指定索引处的字符

  • int compareTo(String str) 按字典顺序比较两个字符串

    • 如果此字符串等于参数字符串,则返回值 0
    • 如果此字符串小于字符串参数,则返回一个小于 0 的值
    • 如果此字符串大于字符串参数,则返回一个大于 0 的值
  • int indexOf(String str) 返回指定子字符串在此字符串中第一次出现处的索引。

  • String replace(char oldChar, char newChar) 返回一个新的字符串,它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的

  • String replaceAll(String regex, String replacement) 使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串

  • String[] split(String regex) 根据给定正则表达式的匹配拆分此字符串。

  • char[] toCharArray() 将此字符串转换为一个新的字符数组。

  • isEmpty() 判断字符串是否为空。

StringBuffer 类

在使用 StringBuffer 类时,每次都会对 StringBuffer 对象本身进行操作,而不是生成新的对象,所以如果需要对字符串进行修改推荐使用 StringBuffer

创建StringBuffer字符串与String大体相同

StringBuffer方法

  • StringBuffer append(String s) 将指定的字符串追加到此字符序列
  • StringBuffer reverse() 将此字符序列用其反转形式取代
  • delete(int start, int end) 移除此序列的子字符串中的字符
  • insert(int offset, int i) 将 int 参数的字符串表示形式插入此序列中的i
  • replace(int start, int end, String str) 使用给定 String 中的字符替换此序列的子字符串中的字符。
  • 其余的方法与String相同

Calendar类

Calendar类是一个抽象类,在实际使用时实现特定的子类的对象,使用getInstance方法创建

创建一个代表系统当前日期的Calendar对象

Calendar cal = Calendar.getInstance();//默认是当前日期

Calendar类对象字段类型

  • Calendar.YEAR 年份

  • Calendar.MONTH 月份

  • Calendar.DATE 日期

  • Calendar.DAY_OF_MONTH 日期,和上面的字段意义完全相同

  • Calendar.HOUR 12小时制的小时

  • Calendar.HOUR_OF_DAY 24小时制的小时

  • Calendar.MINUTE 分钟

  • Calendar.SECOND 秒

  • Calendar.DAY_OF_WEEK 星期几

Calendar类对象信息的获得

Calendar c1 = Calendar.getInstance();

int year = c1.get(Calendar.YEAR);// 获得年份

int month = c1.get(Calendar.MONTH) + 1;// 获得月份

int date = c1.get(Calendar.DATE);// 获得日期

int hour = c1.get(Calendar.HOUR_OF_DAY); // 获得小时

int minute = c1.get(Calendar.MINUTE);// 获得分钟

int second = c1.get(Calendar.SECOND);// 获得秒

常用方法

  • add 把cal对象的日期加上10,也就是c1也就表示为10天后的日期,其它所有的数值会被重新计算
    c1.add(Calendar.DATE, 10);

  • 把c1对象的日期减去10,也就是c1也就表示为10天前的日期,其它所有的数值会被重新计算
    c1.add(Calendar.DATE, -10);


Java图形界面

Java GUI介绍

AWT(Abstract Window Toolkit):

抽象窗口工具包,早期编写图形界面应用程序的包

Swing

Swing:为解决 AWT 存在的问题而新开发的图形界面包。Swing是对AWT的改良和扩展
AWT和Swing都是java中的包,AWT包的名称是java.awt,Swing包的名称是javax.swing

常用的组件(swing中)

  • JLabel 显示一行文字,可带图标
  • JTextFiel 用户让用户输入一行文字的组件
  • JButton 用于点击执行命令
  • JCheckBox 复选框
  • JRadioButton单选按钮
  • JComboBox下拉列表框供选取
  • JList一组列表项供选择

顶层容器 —— JFrame

  • JFrame类是Window类的其中一个子类:通常用于定义一般意义的窗口
  • 一个JFrame刚被创建后,其初始大小为height=width=0 ,而且是隐藏状态的,所以为了使Frame显示出来,必须在程序中显式地设置一下它的大小
    注意:setVisible(true);:数据模型已经构造好,允许JVM可以根据数据模型执行paint方法开始画图并显示到屏幕上

Container类

Container类是由Component类派生出来的一种特殊类,用来表示各种GUI组件的容器,其主要功能包括

  • 组件的管理:方法add()可以向其中添加一个组件,remove()删除其中的一个组件。
  • 布局管理:每个Container类都和一个布局管理器相联,以确定其中组件的布局,通过setLayout()方法设置某种布局方式

中间容器 —— JPanel

JPanel(面板)可以更方便地组织自己的组件,得到更合理的布局。但面板不能作为窗口独立支配系统资源,必须放在相关容器中才可见,因此,需要将JPanel添加到其他容器中得以运行

组件的通用方法

  • void setBackground(Color c) : 设置组件的背景

  • Color getBackground() :获取组件的背景色

  • void setForeground(Color c) :设置组件的前景色

  • void setFont(Font f) :设置组件的显示字体

  • Font getFont() :获取组件的显示字体

  • void setEnabled(boolean b) :是否让组件功能有效,在无效情况下组件变灰

  • void setVisible(boolean b) :设置组件是否可见

  • void requestFocusInWindow() : 让组件得到焦点

  • void add(PopupMenu popup) :给组件加入弹出菜单,但要和弹出菜单的show方法配合使用

常用组件及用法

JLabel 标签组件

  1. JLabel() 创建空的标签
  2. JLabel(String s) 创建一个带初始字符串的标签
  3. JLabel(String s,inti) 创建一个带初始字符串及指定对齐方式的标签(i=0,2,4代表中左右)

JButton 按钮

当组件被点击时,产生AcitonEvent事件

  1. JButton (String Label) 建立一个标示字符串为Label的按钮类对象。
  2. JButton(Icon icon) 创建一个带图标的按钮。

文本框

JTextField 单行文本框

单行文本框只能显示一行信息,会产生多种事件

  1. JTextField() 创建空的单行文本框。
  2. JTextField(int i) 创建具有指定长度的文本框。
  3. JTextField(String s) 创建带有初始文本内容的文本框。
  4. JTextField(String s,int i) 创建带有初始文本内容并具有指定长度的文本框。
JTextArea 多行文本框
  • 多行文本框可以显示多行信息,并且需要滚动条支持。按回车键后并不产生事件
  • 文本域需用setLineWrap(boolean wrap)设置为true,否则可能在规定的宽度不换行。
  • TextArea不支持直接滚动。要创建滚动边框,需要让JTextArea作为JScrollPane的视口视图
文本框的常用方法:
  • getText() 获取输入框中的数据
  • setText() 往输入框写入数据
  • setEditable(boolean b) 设置输入框是否可编辑。

JCheckBox 复选框

提供简单的选择框,同时旁边还可以显示说明信息。当复选框状态发生变化时,会产生ItemEvent事件

常用构造方法:

JCheckBox(String,boolean) 创建一个指定显示标签和初始状态的复选框

常用方法

  • boolean isSelected() 获取复选按钮的选中状态,返回true代表按钮被选中
  • void setSelected(boolean value) 设置复选按钮的状态,valuetrue表示选中。

选框组(ButtonGroup)——单选框

JRadioButton组件单独使用时,与复选框相同;如果利用ButtonGroup类分组,同一组的JRadioButton就构成单选框。选框组中的单选框之间是相互关联的,每次有且只有一个处于选中状态。

JComboBox 下拉列表

下拉列表也称作组合框。它也可以通过addItem (Object s)方法增加选项,但每次只能选择一项。当选择发生时,会产生ItemEvent事件

下拉列表常用方法
  • int getSelectedIndex() 获取所选列表项对应的编号;
  • Object getSelectedItem() 获取所选列表项对应的文字信息;
  • void addItem (Object s) 添加新列表项元素到列表中;
  • void removeItemAt (int Index) 删除某个列表项元素;
  • void removeAllItems() 删除所有列表项元素。

外观布局

  • 在容器(JFrame和JPanel)中所有组件的布局都由布局管理器来控制,他们都有各自默认的布局管理器,也可以依据自身要求指定一个新的布局管理器
  • 容器中布局管理器会自动设置各组件的大小和位置,用户无法手动改变这些属性,即setLocation() , setSize() , setBounds()等方法无效

流式布局(FlowLayout)

FlowLayout以流式的方式,自左向右,自上而下的依次放置容器中的组件,一行放不下时再换行,使用组件的最佳尺寸来显示组件。

当容器被重新设置大小后,则布局也会随之发生改变:各组件的大小不变,但相对位置会改变。
FlowLayout类有三种构造方法:

  • public FlowLayout()
    组件采用居中对齐方式,组件间的水平和竖直间距为默认值5个像素。

  • public FlowLayout(int align)
    使用指定的对齐方式(值=0,1,2,代表左中右),水平和竖直间距为缺省值5像素。

  • public FlowLayout(int align, int hGap, int vGap)
    使用指定的对齐方式、水平间距、竖直间距。

网格布局(GridLayout)

GridLayout布局方式可以使容器中的各组件呈网格状分布。各组件的排列方式仍为从上到下,从左到右。

容器中各组件的高度和宽度相同,当容器的尺寸发生变化时,各组件的相对位置不变,但各自的尺寸会改变。
GridLayout类有三种构造方法:

  • public GridLayout()
    在一行中放置所有的组件,各组件间的水平间距为0像素

  • public GridLayout(int rows, int cols)
    生成一个rows行,cols列的管理器,最多能放置rows*cols个组件。

  • public GridLayout(int rows, int cols, int hGap, int vGap )
    各组件间的水平和竖直间距为指定值

边框布局(BorderLayout)

BorderLayout布局将整个容器的区域分为East, South, West, NorthCenter五个部分,加入组件时需指明放置的位置,如果未指定位置,则位置是Center

当容器的尺寸发生变化时,各组件的相对位置不变,四周组件的厚度不会被改变,中间组件的大小需要改变
BorderLayout类有二种构造方法:

  • public BorderLayout()
    各组件间的水平和竖直间距为缺省值0个像素。

  • public BorderLayout(int hGap, int vGap)
    各组件间的水平和竖直间距为指定值。

若容器使用了BorderLayout布局,用add()方法往容器中添加组件时必须指明添加的位置,若没有指明放置位置,则添加在默认的“Center”方位。


Java事件处理(窗口)

处理步骤

  1. 对于某种类型的xxxEvent,要接受并处理该类时间,必须先定义对应的事件监听器类,该类需要实现针对该类事件的特定接口xxx Listener
  2. 实现该类中事件处理的所有方法
  3. 对于事件源,使用add xxxListener注册该类事件的监听器

事件适配器类xxxAdapter

通过实现接口xxxListener对事件进行处理时,需要实现该接口中的所有方法,但通常只需要对其中的某些方法进行处理,因此JDK为某些监听器接口提供了适配器类

当需要对某种事件进行处理时,只需要让事件处理类继承事件所对应的适配器类,只重写需要关注的方法而不用处理其他

监听器、对应适配器


Java异常处理

异常是一个对象,它继承自Throwable类,该类在java.lang包中,所有的Throwable类的子类所产生的对象都是异常.

  • Error:
    内部错误,由Java虚拟机生成并抛出,Java程序不做处理.

  • Runtime Exception(运行时异常:被0除、数组下标超范围等):
    由系统运行时检测, 用户的Java 程序可不做处理,系统将它们交给缺省的异常处理程序.

  • Checked Exception(程序中可预知的问题:IO异常):
    Java编译器要求Java程序必须捕获或声明所有的非运行时异常

  • throw:
    强行抛出用户自己产生异常

常见的异常处理

  • ClassNotFoundException 指定的类不存在
  • IllegalArgumentException 方法的参数错误
  • NoSuchMethodException 方法不存在异常
  • ArithmeticException 数学运算异常
  • ArrayIndexOutOfBandsException 数组下标超出范围
  • ArrayStoreException 数组存储异常
  • IOException 不能操作I/O
  • FileNotFoundException 文件未找到异常
  • NullPointerException 对象参考值为Null
  • NumberFormatException 字符串转换数值

捕获异常并处理

示例:

try {
//接受监视的程序块,在此区域内发生
//的异常,由catch中指定的程序处理;
}catch(要处理的异常种类对象e1) {
//处理异常;
}catch(要处理的异常种类对象e2) {
//处理异常;
} catch(Exception n) {
//处理其他的异常;
}

finally

不论发生什么异常(或者不发生任何异常),都要执行的部分,在文件处理时非常有用

try {
//对文件进行处理的程序;
}catch(IOException e) {
//对文件异常进行处理;
}finally {
不论是否发生异常,都关闭文件;
}

异常的声明

throwsthrow

  • throws 用来声明一个方法可能产生的所有异常,不做任何处理而是将异常往上传,谁调用我我就抛给谁
  • throw 则是用来抛出一个具体的异常类型

throws

在方法后边声明异常,其实就是自己不想对异常做出任何的处理,告诉别人自己可能出现的异常,交给别人(谁调用的)处理,然后交给他处理
比如:

class Math{
public int div(int i,int j) throws Exception{//丢给上一层
int t=i/j;
return t;
}
}
public class ThrowsDemo {
public static void main(String args[]) throws Exception{
//丢给JVM
Math m=new Math();
}
}

throw

自己处理一个异常,有两种方式要么是自己捕获异常try...catch代码块,要么是抛出一个异常(throws 异常)
用来明确地抛出一个异常,在判断成立时:

throw new 异常;
//example:
<方法名> (<参数行>) [throws<异常类1>,<异常类2>…]{
if (异常条件1成立)
throw new 异常1();
if (异常条件2成立)
throw new 异常2();

} //含有throw 抛出异常的方法,方法头要加上throws 异常列表

自定义异常

注意:

  • 自定义异常不是由Java系统监测到的异常,而只能由用户自己定义的异常

  • 异常是一个类,用户定义的异常必须继承自Throwable或Exception类,建议用Exception类,便于由Exception类统一处理

  • 用户定义的异常必须由用户自己抛出,throw new MyException(),同样要用try--catch捕获。

    class AgeException extends Exception {
    AgeException(){
    super("年龄不正常");
    }
    }
    class MyException2 extends Exception {
    MyException2(String str){
    super(str);
    }
    }

Java Stream/File

Stream

Java IO读写文件的IO流分为两大类,字节流和字符流

  • 基于字节流的读写基类: InputStreamOutputStream

其中比较重要的有BufferedInputStream , FileInputStreamBufferedOutputStreamFileOutputStream

  • 基于字符流的读写基类: ReaderWriter

其中比较重要的有BufferedReader , FileReader , InputStreamReaderBufferedWriter , FileWriter , InputStreamWriter

InputStreamReader

InputStreamReader字节流转换为字符流。是字节流通向字符流的桥梁。如果不指定字符集编码,该解码过程将使用平台默认的字符编码,如:GBK

OutputStreamWriter

OutputStreamWriter字符流转换为字节流。是字符流通向字节流的桥梁。如果不指定字符集编码,该解码过程将使用平台默认的字符编码,如:GBK

File

构造方法

File(String filePath);//filePath:文件路径

常用操作

  • public boolean exists() 测试此抽象路径名表示的文件或目录是否存在

  • public boolean isDirectory() 测试此抽象路径名表示的文件是否是一个目录

  • public boolean isFile() 测试此抽象路径名表示的文件是否是一个标准文件

  • public long lastModified() 返回此抽象路径名表示的文件最后一次被修改的时间

  • public long length() 返回由此抽象路径名表示的文件的长度

  • public boolean delete() 删除此抽象路径名表示的文件或目录

  • public boolean createNewFile() throws IOException当且仅当不存在具有此抽象路径名指定的名称的文件时,原子地创建由此抽象路径名指定的一个新的空文件

  • public boolean mkdir() 创建此抽象路径名指定的目录

  • public boolean delete() 删除此抽象路径名表示的文件或目录


需要注意的

  • java中没有按位左移运算符<<<

  • 创建对象时,数据分配在堆空间,因为堆空间采用链式存储结构,所以能存大量的数据

  • 抽象方法是没有方法体的方法

  • Java API文档不包括: 父类方法的列表

  • JDK中并没有为所有的监听器接口都提供相应的适配器类

  • java变量是否需要初始化
    1、成员变量: 无需初始化
    成员变量无需初始化,系统在创建实例的过程中默认初始化。
    补充:以final修饰的成员变量。必须显性的初始化赋值。

    2、 方法里面的形参变量: 无需初始化
    Java类方法,属于按值传递机制,调用方法的时候,完成参数的传递,相当形参被初始化。

    3、局部变量: 必须初始化

  • JTabbedPane: 选项卡面板

  • 各种进制表示

    • 二进制: 以 0b 或者 0B 开头
    • 八进制: 以 0 开头
    • 十六进制: 以 0x 或者 0X 开头
  • StringBuffer 的初始容量为16

  • Java文档注释: /** balabala */

  • Java的字符类型采用的是Unicode编码方案,每个Unicode码占16个比特位

  • “一次编译、到处运行” 说的是Java语言跨平台的特性

  • Java是通过多线程来实现并发机制的

  • 在 java 源文件中 import 语句应位于 package 语句之后,所有类的定义之前,即先创建当前包,再引用其他包


最后想说的

本篇博客完全是根据自己的掌握情况写的,由于要应付考试,所以其中的重点可能拿捏得不符合一些人的口味,请见谅。后面还会出更多更深入的文章记录Java的学习过程。