课程总结
1.关键字：其实就是某种语言赋予了特殊含义的单词。
保留字：其实就是还没有赋予特殊含义，但是准备日后要使用过的单词。
2.标示符：其实就是在程序中自定义的名词。比如类名，变量名，函数名。包含 0-9、a-z、$、_ ；
注意：
1），数字不可以开头。
2），不可以使用关键字。
3.常量：是在程序中的不会变化的数据。
4.变量：其实就是内存中的一个存储空间，用于存储常量数据。
作用：方便于运算。因为有些数据不确定。所以确定该数据的名词和存储空间。
特点：变量空间可以重复使用。
什么时候定义变量？只要是数据不确定的时候，就定义变量。
变量空间的开辟需要什么要素呢？
1.这个空间要存储什么数据？数据类型。
2.这个空间叫什么名字啊？变量名称。
3.这个空间的第一次的数据是什么？ 变量的初始化值。
数据类型：
1）：基本数据类型：byte、short、int、long、float、double、char、boolean
2）：引用数据类型: 数组、类、接口。
级别从低到高为：byte,char,short(这三个平级)-->int-->float-->long-->double
自动类型转换：从低级别到高级别，系统自动转的；
强制类型转换：什么情况下使用?把一个高级别的数赋给一个别该数的级别低的变量；
运算符号：
1.算术运算符。
+ - * / % %:任何整数模2不是0就是1，所以只要改变被模数就可以实现开关运算。
+:连接符。
++,--
2.赋值运算符。
= += -= *= /= %=
3.比较运算符。
特点：该运算符的特点是：运算完的结果，要么是true，要么是false。
4.逻辑运算符。
& | ^ ! && ||
逻辑运算符除了 ! 外都是用于连接两个boolean类型表达式。
&: 只有两边都为true结果是true。否则就是false。
|:只要两边都为false结果是false，否则就是true
^:异或：和或有点不一样。
两边结果一样，就为false。
两边结果不一样，就为true.
& 和 &&区别： & ：无论左边结果是什么，右边都参与运算。
&&:短路与，如果左边为false，那么右边不参数与运算。
| 和|| 区别：|：两边都运算。
||：短路或，如果左边为true，那么右边不参与运算。
5.位运算符:用于操作二进制位的运算符。
& | ^
<< >> >>>(无符号右移)
5.语句。
If switch do while while for
这些语句什么时候用？
1）、当判断固定个数的值的时候，可以使用if，也可以使用switch。
但是建议使用switch，效率相对较高。
switch(变量){
case 值:要执行的语句;break;
default:要执行的语句;
}
工作原理：用小括号中的变量的值依次和case后面的值进行对比，和哪个case后面的值相同了
就执行哪个case后面的语句，如果没有相同的则执行default后面的语句；
细节：1.break是可以省略的，如果省略了就一直执行到遇到break为止；
2.switch 后面的小括号中的变量应该是byte,char,short,int四种类型中的一种；
3.default可以写在switch结构中的任意位置；如果将default语句放在了第一行，则不管expression与case中的value是否匹配，程序会从default开始执行直到第一个break出现。
当判断数据范围，获取判断运算结果boolean类型时，需要使用if。
当某些语句需要执行很多次时，就用循环结构。
while和for可以进行互换。
区别在于：如果需要定义变量控制循环次数。建议使用for。因为for循环完毕，变量在内存中释放。
break:作用于switch ，和循环语句，用于跳出，或者称为结束。
break语句单独存在时，下面不要定义其他语句，因为执行不到，编译会失败。当循环嵌套时，break只跳出当前所在循环。要跳出嵌套中的外部循环，只要给循环起名字即可，这个名字称之为标号。
continue:只作用于循环结构，继续循环用的。
作用：结束本次循环，继续下次循环。该语句单独存在时，下面不可以定义语句，执行不到。
6.函 数：为了提高代码的复用性，可以将其定义成一个单独的功能，该功能的体现就是java中的函数。函数就是体现之一。
java中的函数的定义格式：
修饰符 返回值类型 函数名(参数类型 形式参数1，参数类型 形式参数1，…){
执行语句；
return 返回值；
}
当函数没有具体的返回值时，返回的返回值类型用void关键字表示。
如果函数的返回值类型是void时，return语句可以省略不写的，系统会帮你自动加上。
return的作用：结束函数。结束功能。
如何定义一个函数？
函数其实就是一个功能，定义函数就是实现功能，通过两个明确来完成：
1.明确该功能的运算完的结果，其实是在明确这个函数的返回值类型。
2.在实现该功能的过程中是否有未知内容参与了运算，其实就是在明确这个函数的参数列表(参数类型&参数个数)。
函数的作用：
1.用于定义功能。
2.用于封装代码提高代码的复用性。
函数中只能调用函数，不能定义函数。
主函数：
1.保证该类的独立运行。
2.因为它是程序的入口。
3.因为它在被jvm调用。
函数定义名称是为什么呢？
答：1.为了对该功能进行标示，方便于调用。
2.为了通过名称就可以明确函数的功能，为了增加代码的阅读性。
重载的定义是：在一个类中，如果出现了两个或者两个以上的同名函数，只要它们的参数的个数，或者参数的类型不同，即可称之为该函数重载了。
如何区分重载：当函数同名时，只看参数列表。和返回值类型没关系。
7.数 组：用于存储同一类型数据的一个容器。好处：可以对该容器中的数据进行编号，从0开始。数组用于封装数据，就是一个具体的实体。
在java中表现一个数组有两种表现形式：
1.元素类型[] 变量名 = new 元素类型[元素的个数]；
2.元素类型[] 变量名 = {元素1，元素2...}；
元素类型[] 变量名 = new 元素类型[]{元素1，元素2...}；
三：面向对象：
3特点：1.将复杂的事情简单化。
2.面向对象将以前的过程中的执行者，变成了指挥者。
3.面向对象这种思想是符合现在人们思考习惯的一种思想。
过程和对象在我们的程序中是如何体现的呢？过程其实就是函数；对象是将函数等一些内容进行了封装。
匿名对象使用场景：
1.当对方法只进行一次调用的时候，可以使用匿名对象。
2.当对象对成员进行多次调用时，不能使用匿名对象。必须给对象起名字。
在类中定义其实都称之为成员。成员有两种：
1.成员变量：其实对应的就是事物的属性。
2.成员函数：其实对应的就是事物的行为。
所以，其实定义类，就是在定义成员变量和成员函数。但是在定义前，必须先要对事物进行属性和行为的分析，才可以用代码来体现。
private int age;//私有的访问权限最低，只有在本类中的访问有效。注意：私有仅仅是封装的一种体现形式而已。
私有的成员：其他类不能直接创建对象访问，所以只有通过本类对外提供具体的访问方式来完成对私有的访问，可以通过对外提供函数的形式对其进行访问。好处：可以在函数中加入逻辑判断等操作，对数据进行判断等操作。
总结：开发时，记住，属性是用于存储数据的，直接被访问，容易出现安全隐患，所以，类中的属性通常被私有化，并对外提供公共的访问方法。
这个方法一般有两个，规范写法：对于属性 xxx，可以使用setXXX(),getXXX()对其进行操作。
构造函数：用于给对象进行初始化，是给与之对应的对象进行初始化，它具有针对性，函数中的一种。
特点：
1：该函数的名称和所在类的名称相同。
2：不需要定义返回值类型。
3：该函数没有具体的返回值。
所有对象创建时，都需要初始化才可以使用。
注意事项：一个类在定义时，如果没有定义过构造函数，那么该类中会自动生成一个空参数的构造函数，为了方便该类创建对象，完成初始化。如果在类中自定义了构造函数，那么默认的构造函数就没有了。
一个类中，可以有多个构造函数，因为它们的函数名称都相同，所以只能通过参数列表来区分。所以，一个类中如果出现多个构造函数。它们的存在是以重载体现的。
封 装（面向对象特征之一）：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
好处：将变化隔离；便于使用；提高重用性；安全性。
封装原则：将不需要对外提供的内容都隐藏起来，把属性都隐藏，提供公共方法对其访问。
This：代表对象，就是所在函数所属对象的引用。
在定义功能时，如果该功能内部使用到了调用该功能的对象，这时就用this来表示这个对象。
this 还可以用于构造函数间的调用。
调用格式：this(实际参数)；
this对象后面跟上 . 调用的是成员属性和成员方法(一般方法)；
this对象后面跟上 () 调用的是本类中的对应参数的构造函数。
用this调用构造函数，必须定义在构造函数的第一行。因为构造函数是用于初始化的，所以初始化动作一定要执行。否则编译失败。
static：关键字，是一个修饰符，用于修饰成员(成员变量和成员函数)。
特点：1.想要实现对象中的共性数据的对象共享，可以将这个数据进行静态修饰。
2.被静态修饰的成员，可以直接被类名所调用。也就是说，静态的成员多了一种调用方式。类名.静态方式。
3.静态随着类的加载而加载，而且优先于对象存在。
Public：访问权限最大。
static：不需要对象，直接类名即可。
void：主函数没有返回值。
Main：主函数特定的名称。
(String[] args)：主函数的参数，是一个字符串数组类型的参数，jvm调用main方法时，传递的实际参数是 new String[0]。
静态代码块、构造代码块、构造函数同时存在时的执行顺序：静态代码块 à 构造代码块 à 构造函数；
继 承（面向对象特征之一）
好处：1.提高了代码的复用性。
2.让类与类之间产生了关系，提供了另一个特征多态的前提。
父类的由来：其实是由多个类不断向上抽取共性内容而来的。
java中对于继承，java只支持单继承。java虽然不直接支持多继承，但是保留了这种多继承机制，进行改良。
单继承：一个类只能有一个父类。
多继承：一个类可以有多个父类。
为什么不支持多继承呢？
因为当一个类同时继承两个父类时，两个父类中有相同的功能，那么子类对象调用该功能时，运行哪一个呢？因为父类中的方法中存在方法体。
但是java支持多重继承。A继承B B继承C C继承D。
多重继承的出现，就有了继承体系。体系中的顶层父类是通过不断向上抽取而来的。它里面定义的该体系最基本最共性内容的功能。
所以，一个体系要想被使用，直接查阅该系统中的父类的功能即可知道该体系的基本用法。那么想要使用一个体系时，需要建立对象。建议建立###最子类对象，因为最子类不仅可以使用父类中的功能。还可以使用子类特有的一些功能。
3.构造函数。
子类的所有构造函数中的第一行，其实都有一条隐身的语句super();
super(): 表示父类的构造函数，并会调用于参数相对应的父类中的构造函数。而super():是在调用父类中空参数的构造函数。
为什么子类对象初始化时，都需要调用父类中的函数？(为什么要在子类构造函数的第一行加入这个super()?)
因为子类继承父类，会继承到父类中的数据，所以必须要看父类是如何对自己的数据进行初始化的。所以子类在进行对象初始化时，先调用父类的构造函数，这就是子类的实例化过程。
子类中所有的构造函数都会默认访问父类中的空参数的构造函数，因为每一个子类构造内第一行都有默认的语句super();
如果父类中没有空参数的构造函数，那么子类的构造函数内，必须通过super语句指定要访问的父类中的构造函数。
如果子类构造函数中用this来指定调用子类自己的构造函数，那么被调用的构造函数也一样会访问父类中的构造函数。
super()或者this()都是调用构造函数，构造函数用于初始化，所以初始化的动作要先完成
final特点：
1.这个关键字是一个修饰符，可以修饰类，方法，变量。
2.被final修饰的类是一个最终类，不可以被继承。
3.被final修饰的方法是一个最终方法，不可以被覆盖。
4.被final修饰的变量是一个常量，只能赋值一次。
抽象类: abstract
抽象：不具体，看不明白。抽象类表象体现。
在不断抽取过程中，将共性内容中的方法声明抽取，但是方法不一样，没有抽取，这时抽取到的方法，并不具体，需要被指定关键字abstract所###标示，声明为抽象方法。
抽象方法所在类一定要标示为抽象类，也就是说该类需要被abstract关键字所修饰。
抽象类的特点：
1.抽象方法只能定义在抽象类中，抽象类和抽象方法必须由abstract关键字修饰（可以描述类和方法，不可以描述变量）。
2.抽象方法只定义方法声明，并不定义方法实现。
3.抽象类不可以被创建对象(实例化)。
4.只有通过子类继承抽象类并覆盖了抽象类中的所有抽象方法后，该子类才可以实例化。否则，该子类还是一个抽象类。
抽象类的细节：
1.抽象类中是否有构造函数？有，用于给子类对象进行初始化。
2.抽象类中是否可以定义非抽象方法？
可以。其实，抽象类和一般类没有太大的区别，都是在描述事物，只不过抽象类在描述事物时，有些功能不具体。所以抽象类和一般类在定义上，都是需要定义属性和行为的。只不过，比一般类多了一个抽象函数。而且比一般类少了一个创建对象的部分。
3.抽象关键字abstract和哪些不可以共存？final , private , static
4.抽象类中可不可以不定义抽象方法？可以。抽象方法目的仅仅为了不让该类创建对象。
图形界面
mport javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.io.*;
public class wordpad implements ActionListener {
JFrame jf;
JMenuBar jmb;
JMenu filem,editMenu,formatm,viewm,helpm;
JMenuItem newi,openi,savei,closei,pagei,printi,savedi;
JScrollPane jsp;
JTextArea area;
JFileChooser jfc;
File file;
public wordpad(){
jf = new JFrame("记事本");
jmb = new JMenuBar();
//建立菜单
filem= new JMenu("文件(F)");
editMenu= new JMenu("编辑(E)");
formatm = new JMenu("格式(O)");
viewm = new JMenu("查看(V)");
helpm = new JMenu("帮助(H)");
//实例化菜单项
newi = new JMenuItem("新建(N)");
openi = new JMenuItem("打开(O)");
savei = new JMenuItem("另存为(A)");
closei = new JMenuItem("关闭(X)");
pagei = new JMenuItem("页面设置(U)");
printi = new JMenuItem("打印(P)");
savedi = new JMenuItem("保存(S)");
area = new JTextArea();
jsp = new JScrollPane(area);
newi.addActionListener(this);
openi.addActionListener(this);
savei.addActionListener(this);
closei.addActionListener(this);
pagei.addActionListener(this);
printi.addActionListener(this);
savedi.addActionListener(this);
//给‘文件’菜单添加菜单项
filem.add(newi);
filem.add(openi);
filem.add(savedi);
filem.add(savei);
filem.addSeparator();
filem.add(pagei);
filem.add(printi);
filem.addSeparator();
filem.add(closei);
//给菜单项设置助记符和快捷键
newi.setMnemonic('N');
newi.setAccelerator(KeyStroke.getKeyStroke('N',java.awt.Event.CTRL_MASK));
openi.setMnemonic('O');
openi.setAccelerator(KeyStroke.getKeyStroke('O',java.awt.Event.CTRL_MASK));
savei.setMnemonic('A');
savei.setAccelerator(KeyStroke.getKeyStroke('A',java.awt.Event.CTRL_MASK));
closei.setMnemonic('X');
closei.setAccelerator(KeyStroke.getKeyStroke('X',java.awt.Event.CTRL_MASK));
pagei.setMnemonic('U');
pagei.setAccelerator(KeyStroke.getKeyStroke('U',java.awt.Event.CTRL_MASK));
savedi.setMnemonic('S');
savedi.setAccelerator(KeyStroke.getKeyStroke('S',java.awt.Event.CTRL_MASK));
printi.setMnemonic('P');
printi.setAccelerator(KeyStroke.getKeyStroke('P',java.awt.Event.CTRL_MASK));
jmb.add(filem);
jmb.add(editMenu);
jmb.add(formatm);
jmb.add(viewm);
jmb.add(helpm);
jf.setJMenuBar(jmb);
jf.add(jsp); //滚动条加到窗体上，需要时显示
jf.setSize(600,500);
jf.setLocation(400,100);
jf.setVisible(true);
}
@Override
public void actionPerformed(ActionEvent event){
Object obj = event.getSource();
if(obj instanceof JMenuItem){
JMenuItem item = (JMenuItem)obj;
if(item == newi){ //新建
new wordpad();
}else if(item==openi){ //打开
jfc=new JFileChooser();
jfc.showOpenDialog(null);
file = jfc.getSelectedFile();
try {
FileInputStream fis = new FileInputStream(file);
byte[] b = new byte[fis.available()];
fis.read(b); //将文件内容读入程序中
area.append(new String(b)); //再输出到文本框中
fis.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
else if(item==savei) { //另存为
jfc=new JFileChooser();
jfc.showSaveDialog(null);
file = jfc.getSelectedFile(); //返回选择的文件
try {
if(!file.exists()) { //如果不存在这个文件就新建一个，如果已存在，就直接保存到已有的这个文件中
file.createNewFile();
}
FileOutputStream fos = new FileOutputStream(file);
byte[] b = area.getText().getBytes();
fos.write(b);
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
else if(item==savedi) { //保存
}
else if(item==pagei) {
}
else if(item==printi) {
}
else if(item==closei) {
System.exit(1);
}
}
}
}
java图形界面的建立是其实是一个很条理的过程，容器就是画板，panel就是给这张纸划分的区域，像JLabel等小组件就是在这些区域画的具体的物象，我们所做的事情就是将我们想要的组件分别画在几个区域，再将这几个排好顺序放到容器中即可.
一、字节流和字符流
字节流和字符流都包括输入和输出操作，字节流中输出数据主要使用outputStream完成，输入使用的是InputStream，在字符流中输出主要使###用Writer类完成，输入主要是使用Reader类完成
内容操作四个类：OutputStream，InputStream，Writer,Reader 这四个类都是抽象类
IO操作的响应步骤：
（1）首先使用File类打开一个文件
（2）通过字节流或字符流的子类，指定输出的位置
（3）进行读/写操作
（4）关闭输入/输出