课程总结

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）关闭输入/输出

IO操作属于资源操作，在操作完毕后必须关闭，否则可能会出现未知错误

二、字节流

1.字节流操作的是byte类型的数据。所有的数据基本上都可以用byte数组表示出来

2.OutputStream是字节输出流的最大父类，在操作的时候如果文件不存在，则会为用户创建新文件

3.InputStream是字节输入流的最大父类，如果是从文件中读取，子类一定是FileInputStream

4.OutputStream和InputStream都是抽象类.

三、字符流

1.字符流操作的是字符

2.Writer类，和OutputStream相比，Writer更加方便，因为不用把想要输出的字符转换成byte

3.Reader类，和InputStream相比基本上相同，只是用来接收数据的一个是byte数组，一个是char数组

四、字节流和字符流的区别

1.字节流在操作的时候本身是不会用到缓存区（内存）的，是与文件本身直接操作的，而字符流在操作的时候是使用到缓冲区的

2.字符流在操作时，操作内容会先保存在缓冲区，只有刷新缓冲区的时候才能输出相应的操作

五、开发中的使用

字符只有在内存中才会形成，所以最好使用字节流操作文件

六、字节流和字符流之间的转换

1.OutputStreamWriter是Writer的子类，是把字符流的输出对象转化为字节流对象

2.InputStreamReader是Reader的子类，是把字节流的输入对象转化为字符流对象

3.FileWriter不是Writer的子类，而是转换流OutputStreamWriter的子类

4.FileReader不是Reader子类，而是转化流InputStreamReader的子类

5.传输或者是从文件中读取数据的时候，文件里真正保存的数据永远是字节

七、管道流

管道输出流PipedOutputStream,管道输入流PipedInputStream。管道流主要##是实现两个线程之间的输出流和输入流。

八、打印流、

字节流PrintStream,字符流PrintWriter。PrintStream可以指定输出位置

printStream可以方便的完成输出的功能，属于装饰设计模式

九、System对IO的三种支持

System.Out, System.in, System.err

System.Out是希望用户看到的

System.err是不希望用户看到的

输入输出重定向

课程总结

原文：https://www.cnblogs.com/buxiu888/p/12037267.html