1，java的特点：语法简单，面向对象，稳定，与平台无关，多线程，动态等特点，而与平台无关是java风靡全球的重要原因。（与平台无关是指软件的运行不因操作系统、处理器的变化而无法运行或出现运行错误）

注：java可以在计算机的操作系统上再提供一个java运行环境（JRE，Java Runtime Environment）,该环境由java虚拟机JVM、类库和一些核心文件组成。

2，在一个计算机上编译得到的字节码（.class）文件可以复制到任何一个安装了java运行环境的计算机上直接使用。字节码文件由java虚拟机解释运行，即java虚拟机负责把字节码翻译成本地计算机能识别的机器码，并将机器码交给本地的操作系统运行。

3,".;"是指可以加载应用程序当前目录及其子目录中的类。

4，java基本格式：publicclass 类名｛     //S必须是大写

                          publicstatic void main(String args[]){

                                   System.out.println("Helloworld");//println表示输出换行，print输出不换行。

                                                     }

                                            }       //java源程序必须在纯英文状态下编写。包括标点符号，java语言严格区分大小写，输出字符串不受限制。

5，如果源文件有多个类，那么只能有一个类是public类，如果有一个类是public类，那么原文件的名字必须与这个类的名字完全相同，扩展名.java。

6，一个java应用程序必须有一个类含有publicstatic void main(String args[])方法，称这个类为主类（保证程序的独立运行，若没有编译时会报错，缺少main）,一对大括号｛｝阔起来的是代码块。

编程风格，独行风格（大括号各占一行，适用于代码较少时），行尾风格（第一个大括号在上一行代码结尾处，第二个大括号独占一行，适用于代码较多时）。

7，写程序步骤： 需求：程序要完成什么功能。

                                   思路：第一步为使程序独立运行必须有主类;第二步明确是否有不确定的                                           量参与（定义变量）;

步骤：按照思路写代码，每行代码应该有注释，提高程序代码的阅读性，即表明语句主要实现的功能。

8，标识符：就是名字，由字母、数字、下划线和美元符号组成，长度不受限制。标识符第一个字符不能是数字，不是能是关键字，也不能是逻辑常量ture、false,null，标识符区分大小写。java使用的是Unicode标准字符集，可识别65536个字符，前128个恰好是ASCII码。（规范：类名若有多个单词组成则每个单词首字母大写，方法名若有多个单词组成，第一个单词首字母小写其余单词首字母都大写）

9，关键字：abstract(抽象的)、assert()、boolean(逻辑类型)、break()、byte(字节型)、case(事件)、catch()、char(字符)、class(类)、const()、continue(继续)、default()、do()、double(双精度)、else(否则)、enum()、extends(继承)final(最终)、finaly()、float(单精度)、for(循环结构)、goto()if(如果)、import(引入)、instanceof()、int(整型)、interface(接口)、long(长整型)、native()、new(运算符)、package(打包)、private(私有的)、protected(受保护的)、public(公有的)、return(返回)、short(短整型)、static(静态的)strictfp()、super()、switch(选择)synchronized()、this()、throw()、throws()、transient()、try()、void(空类型)、volatile()、while()

10，基本数据类型：

逻辑类型（boolean）整数类型（byte占一个字节，short占两个字节，int占四个字节，long占八个字节）字符类型（char占两个字节）浮点类型（float常量后面必须要有后缀f或F，存储时保留八位有效数字。double存储时保留十六位有效数字）引用类型（数组、对象和接口）

精度从低到高：byte short char int long float double (精度低的变量赋值给精度高的变量时系统会自动进行类型转换，精度高的变量赋值给精度低的变量时要强制类型转换，否则会提示“可能会丢失精度”java是强类型语言)

注，java中一定是无符号的。e是指数型后面一定是整数。

11，转移字符：\n(换行)，\b(退格)，\t(水平制表)，\'(单引号)，\"(双引号)，\\(反斜线)。+ 并置符号（连字符）

12，格式控制符：%d:输出整型 %c:输出字符型 %f:输出浮点型，小数点最多保留六位 %s:输出字符串 %m.nf：小数点保留n位。

13，折半法（二分法）：对于从小到大排序的数组，只要判断数据和数组中间值是否相等，如果不相等，当该数据小于数组中间值，则在前一半数据中继续折半查找，否则就在后一半数据中折半找。（最多找n/2次，防止陷入死循环）

14，运算符：自增在前先增后用，自增在后先用后加。运算符的优先级决定了运算顺序。

15，break跳出整个循环（结束循环），continue结束本次循环，转入下一次循环。

16，面向对象语言特点：封装性（将数据和对数据的操作封装在一起）继承性（extends）多态性（相同的操作作用于不同的对象产生不同的行为）。

17，定义类：class 类名｛类体｝//类的目的是抽象出一类事物共有的属性和行为。

定义方法：修饰符返回值类型 方法名（参数类型 方法参数）

｛方法体｝//构造方法无任何修饰，成员变量在整个类中有效，局部变量（在方法体中声明的变量）在方法体内有效。

（编程风格：一行只声明一个变量，变量名见名知义，）

18，使用隐藏的成员变量，必须使用关键字this。注：非变量声明必须出现在方法体中。

19，类的UML图：      类名

                                            成员变量：类型

                                            方法：类型

20，构造方法：类中的构造方法必须与类名完全相同，而且没有类型。（构造方法是产生对象的），一个类中可以有多个构造方法，但是构造方法必须用参数区分。

21，对象的声明：类的名字 对象的名字（对象用“.”运算符操作自己的变量和调用类中的方法），java有所谓的“垃圾收集”机制，这种机制周期的检测某个实体是否已不再被任何对象拥有（引用），如果发现这样的实体，就释放实体占有的内存。

22，在java中所有参数都是“传值”的，也就是说方法中参数变量的值是调用者指定值的拷贝。

23，形参的改变会影响实参的变化。

24，类之间有关系，关联关系（如果A类中的成员变量是B类中声明的对象时，就构成了关联关系）

依赖关系（如果A类中某个方法参数是B类声明的对象或某个方法返回的数据类型是B类对象，那么A和B的关系就是依赖关系）。

25，实例变量和类变量的区别：

不同对象的实例变量互不相同;所有对象共享类变量;通过类名直接访问类变量;（类变量不仅可以通过某个对象访问，也可以直接通过类名访问。）

实例变量仅仅是和相应的对象关联的变量，不同对象的实例变量不同，分配的空间不同，改变其中一个对象的实例变量不会影响其他对象的这个实例变量，对象的实例变量可以通过该对象访问，但不能用类名访问。

26，用static修饰的方法是类方法（静态方法）。否则是实例方法。

实例方法不仅可以操作实例变量，也可以操作类变量，而且类方法不可以操作实例变量。

27，方法重载：一个类中可以有多个方法具有相同的名字，但这些方法的参数必须不同。（参数个数不同或某个参数类型不同，既是方法返回值类型不同，也必须保证参数不同）

注：重载方法必须在同一个类中。

28，this是java的一个关键字表示某个对象。this可以出现在实例方法和构造方法中，但不可以出现在类方法中。

this出现在构造方法中时，代表使用该构造方法所创建的对象。实例方法只能通过对象来调用，不能用类名来调用。当this出现在实例方法中时，this就代表正在调用该方法的当前对象（格式：this.成员变量）。

通常情况下，可以省略实例变量名字前面的“this”，以及static变量前面的“类名.”.

当实例成员变量的名字和局部变量的名字相同时，成员变量前面的“this.”或“类名.”就不可以省略（格式：this.方法    类名.方法）

29，包名的目的是有效的区分名字相同的类。(格式：package 包名 //指的是类存放的相对路径，和操作系统的文件路径想对应，打包的是字节码文件，包名.主类名）包名可以是合法的标识符，也可以是若干标识符由“.”分割而成。Package a.b则存储文件（.class）的目录必须含有…a\b。里面存放包所包含的所有类字节码文件。

30，类库中的类：java.lang         包含所有的基本语言类

         `                         javax.swing     包含抽象窗口工具集中的图形、文本、窗口GUI类

                                   java.io              包含所有的输入输出类

                                   java.util   包含实用类

                                   java.sql    包含所有的数据库的类

                                   java.net   包含所有实现网络功能的类

注：如果要引入一个包中的所有类，则可以用通配符星号（*）来代替。

引入包中的意义：程序员能很容易确定同一个包中的类是关联。

31，访问权限是指对象是否可以通过“.”运算符操作自己的变量或通过“.”运算符调用类中的方法。访问限制修饰符private、protected和public。

类中的实例方法总是可以操作类中的实例变量和类变量;类方法总是可以操作类中的类变量，与访问修饰符没有关系。

注：不加任何修饰的变量和方法是友好的，

32，继承是一种由已有的类创建新类的机制。继承而得到的类称为子类，被继承的类称为父类。格式：class 子类名 extends 父类名｛｝

若子类和父类在一个包中，子类就继承了其父类中不是private的成员变量和方法，继承的成员变量和方法访问权限保持不变。

用子类创建对象时也为父类分配了内存空间。

注：java不支持多重继承，即子类只能有一个父类。既是是私有变量也要分配空间。

33，成员变量的隐藏：子类所声明的成员变量和从父类继承来的成员变量名字相同时，子类会隐藏继承的成员变量。

34，方法重写：是指子类中定义一个方法，这个方法类型和父类的类型一致或者是父类的方法的类型的子类型（所谓的类型是指，如果父类的方法的类型是“类”，那么允许子类的重写方法的类型是“子类”），并且这个方法的名字、参数个数、参数的类型和父类的方法完全相同。子类如此定义的方法称作子类重写的方法。

重写的目的：子类通过方法的重写可以隐藏继承的方法，子类通过方法的重写可以把父类的状态和行为改变为自身的状态和行为。

注：重写父类的方法时，不允许降低方法访问权限，但可以提高访问权限（访问权限从高到低是：public,protected,有好的，private）

注：子类重写的方法操作的是子类声明的同名变量;子类继承的方法操作的是继承的变量;子类不继承父类的构造方法。

35，super关键字：子类一旦隐藏了继承的成员变量，那么子类创建的对象就不再拥有该变量，该变量将归关键字super所拥有，同样，子类一旦隐藏了继承的方法，那么子类创建的对象就不能调用被隐藏的方法，该方法的调用由关键字super负责。子类想使用被子类隐藏的成员变量和方法时就需要用super关键字。

36，final关键字：修饰的类不能被继承，修饰的方法不允许重写，修饰的变量值不能变（常量）。

37，上转型对象：定义1:如果父类声明了这个对象，这个对象由子类来分配空间，则这个对象称为子类的上转型对象。

定义2：当子类创建一个对象，并把这个对象的引用放到父类的对象中时。

上转型对象不能操作子类新增的变量，不能调用新增的方法。上转型对象可以访问子类继承或隐藏的变量，也可以调用子类继承或子类重写的实例方法

注意：若子类重写了父类的某个实例方法后，当对象的上转型对象调用这个实例方法时一定调用了子类重写的实例方法。多态性就是指父类的某个方法被子类重写时，可以各自产生自己的功能行为。

38，用关键字abstract修饰的类称为abstract类（抽象类）。

对于abstract方法，只允许声明，不允许实现（没有方法体），而且不允许abstract和final同时修饰一个方法或类，也不允许使用static修饰abstract方法，即abstract方法必须是实例方法。

abstract类不能用new运算符来创建对象（如果一个非抽象类是某个抽象类的子类，那么他必须重写父类的抽象方法，给出方法体，去掉abstract），abstract类的对象做上转型对象。

注：abstract方法只能出现在abstract类中，并且abstract类中允许有非abstract方法。

39，面向抽象编程：原则，让设计和实现分离

使用多态技术的核心技术之一是使用上转型对象，即将abstract类声明的对象作为其子类对象的上转型对象，那么这个上转型对象就可以调用子类重写的方法。

所谓面向抽象编程，是指当设计某种重要的类时，不让该类面向具体的类，而是面向抽象类，即所设计类中的重要数据是抽象类声明的对象，而不是具体类声明的对象。

目的是：为了应对用户需求的变化，将某个类中经常因需求变化而需要改动的代码从该类中分离出去。面向抽象编程的核心是让类中的每种可能的变化对应的交给抽象类的一个子类去负责;从而让该类的设计者不去关心具体的实现，避免所设计的类依赖于具体的实现。面向抽象编程使设计的类容易应对用户需求变化。

注：使变化的代码和稳定的代码之间成为松耦合关系，即将每种可能的变化对应的交给抽象类的子类去负责完成。

40，开-闭原则：就是让所设计的系统应当对扩展开放，对修改关闭。若遵守了“开-闭”原则，那么该系统一定是易维护的。

抽象类用来派生子类。

小技巧：1、Arrays.sort(a);对数组a进行排序，index=Arrays.binarySearch(a,number);用二分法在a数组中查找number。if(index>=0)证明找到了数字number。

2、for(i=0;i<=a.length;i++){

if(Character.isLowerCase(a[i]))

a[i]=Character.toUpperCase(a[i]);//将小写字母变成大写字母。

else if(Character.isUpperCase(a[i]))

a[i]=Character.toLowerCase(a[i]);//将大写字母变成小写字母。

}

Java中的其他doc命令：

javaap.exe可以将字节码文件反编译成源码（格式：1、javaap 包名.类名 将列出该类中的所有public方法和public成员变量2、javaap –private包名.类名将列出所有的方法和成员变量）

javadoc.exe可以制作源文件类的html格式文档（javadoc –d要保存html文件的目录 java源文件将html文档保存在特定的文件夹下面）

jar.exe命令把一些类的字节码(.class）文件压缩成一个jar文件。清单文件：.mf（Manifestfiles）

格式：    Manifest-version:空格1.0

                  Class:空格包名.类名 包名.类名 …

                  Greated-By:空格1.6

接口

interface 接口的名字｛常量的声明和抽象方法｝接口体中只有抽象方法，接口体中的所有的常量的访问权限一定都是public，而且是static常量（允许省略public,final,和static修饰符），所有抽象方法访问权限一定是public 的方法（允许省略public abstract）

接口的实现：一个类需要在类声明中使用关键字implements声明该类实现了一个或多个接口，如果实现的多个接口，用逗号隔开接口名。

格式：class 类名 implements 接口1，接口2，…

如果一个非抽象类实现了某个接口，那么该类必须重写这个接口中的所有方法。由于接口中的方法一定是public abstract方法，所以类在重写接口的方法时不仅要去掉abstract修饰符，给出方法体，而且方法的访问权限一定要明显地用public来修饰（否则就降低了权限，这是不允许的）。

注：1、直接使用接口中的常量2、用接口名访问接口常量

如果一个类声明实现一个接口，但没有重写接口中所有方法，那么该类一定是抽象类，也就是说抽象类既可以重写接口中的方法也可以直接拥有接口中的方法

程序可以用接口名访问接口中的常量，但是如果一个类实现了接口，那么该类可以直接在类体中使用该接口中的常量。

Public接口能被任何一个类实现。有好接口可以被同一个包中的类实现。如果父类实现了某个接口那么子类也就自然实现了某个接口，子类不必用关键字implements声明实现该接口。

接口可以通过关键字extends声明一个接口是另一个接口的子接口，子接口将继承父接口中全部的方法和常量。接口可以通过import引入。

接口的思想在于它可以要求某些类有相同名称的方法，但方法的具体内容可以不同，即要求这些类实现接口，以保证这些类一定有接口中所声明的方法（即所谓的方法绑定），接口在要求某些类具有相同名称的方法时，并不强迫这些类具有相同的父类。

接口回调：是指可以把实现某一接口的类创建的对象的引用赋值给该接口声明的接口变量，那么该接口变量就可以调用被类实现的接口方法。实际上，当接口变量调用被类实现的接口方法时，就是通知相应的对象调用这个方法。

接口产生的多态就是指不同的类在实现同一个接口时可能具有不同的实现方式，那么接口变量在回调接口方法时就可能具有多种形态。

如果一个方法的参数是接口类型，就可以将任何实现该接口的类的实例的引用传递给该接口参数，那么该接口参数就可以回调类实现的接口方法。

使用程序设计的核心思想是使用接口回调，即接口变量存放实现接口的类的对象的引用，从而接口变量就可以回调类实现的接口方法。利用接口也体现“开-闭原则”，即对扩展开放，对修改关闭。把每种可能的变化对应地交给实现接口的类去负责完成。

内部类和异常类

Java支持在一个类中定义另一个类，这样的类称作内部类，而包含内部类的类称为内部类的外嵌类。

关系：1、内部类的外嵌类的成员变量在内部类中仍然有效，内部类中的方法也可以调用外嵌类中的方法。

2、内部类的类体中不可以声明类变量和类方法。外嵌类的类体中可以用内部类声明对象，作为外嵌类的成员。

3、内部类仅供它的外嵌类使用，其他类不可以用某个类的内部类声明对象。

4、内部类的外嵌类的成员变量在内部类中有效，使得内部类与外嵌类的交互更加方便。

Java编译器生成的内部类的字节码文件的名字和通常的类不同，内部类对应的字节码文件的名字格式是“外嵌类名$内部类名”，内部类可以被static修饰，类是一种数据类型，那么static内部类就是外嵌类的一种静态数据类型，这样一来，程序就可以在其他类中使用static内部类来创建对象了。但需要注意，static内部类不能操作外嵌类中的实例成员变量。

注：非内部类不可以是static类。

创建子类对象时，除了使用父类的构造方法外还有类体，此类体被认为是一个子类去掉类声明后的类体，称做匿名类，匿名类就是一个子类，由于无名可用，所以不可能用匿名类声明对象，但却可以直接用匿名类创建一个对象。

格式：new 类名（）｛

匿名类的类体

｝；

匿名类有如下特点：匿名类可以继承父类的方法也可以重写父类的方法。

使用匿名类时，必然在某个类中直接使用匿名类创建对象，因此匿名类一定是内部类。

匿名类可以访问外嵌类中的成员变量和方法，匿名类的类体中不可以声明static成员变量和static方法。

若方法的参数是类类型，而且希望向方法传递该类的子类对象，但系统没有提供符合要求的子类，那么就可以考虑用匿名类。

由于匿名类是一个子类，但没有类名，所以在用匿名类创建对象时，要直接使用父类的构造方法。

Java允许直接使用 接口名和一个类体创建一个匿名对象，此类体被认为是实现了某接口的类去掉类声明后的类体，称作匿名类。

格式：new 接口名（）｛

实现接口的匿名类的类体

｝

如果某个方法的参数是接口类型，那么可以使用接口名和类体组合创建一个匿名对象传递给方法参数，类体必须要重写接口中的全部方法。

注：匿名类放在方法参数中

一个没有名字的内部类，由匿名类所产生的对象常常被用作上转型对象或接口回调。

异常类：程序运行时可能出现的一些错误。Java使用throw

关键字抛出一个Exception子类的实例表示异常发生。

Java允许定义方法时声明该方法调用过程中抛出异常对象，即允许方法调用过程中抛出异常对象，终止当前方法的继续执行。

原理：将可能出现的异常代码和异常处理分开。

Try-catch语句

Java用try-catch语句处理异常，将可能出现的异常操作放在try-catch语句的try部分，一旦try部分抛出异常对象，那么try部分将立刻结束执行，转向执行相应的catch部分。所以将程序的异常处理放在catch部分。

格式：try{

包含可能发生异常的语句

}

catch(ExceptionSubClass1 e){ … }

catch(ExceptionSubClass2 e){ … }

catch(ExceptionSubClass3 e){ … }//catch中的参数是Exception的某个子类。这些子类之间不能有父子关系

throw关键字抛出异常对象。throws关键字声明要产生的异常。

断言语句一般用于程序不准备通过捕获异常来处理的错误。assert声明一条断言语句

格式：assert （可求值的）逻辑表达式;当表达式为ture时继续执行，否则程序立刻结束执行。

assert （可求值的）逻辑表达式：（可求值的）字符串表达式;表达式值为ture时，继续执行。当值为false时，程序结束执行，并输出字符串表达式的值。

Java解释器直接运行程序时，默认的关闭断言语句，在调试程序时可以使用-ea启用断言语句。

finally子语句的try-catch语句格式：

try{}

catch(ExceptionSubClass1 e){ … }

finally{}

执行机制：在执行try-catch语句后，执行finally子语句，也就是说无论try-catch部分是否发生异常，finglly子语句都会被执行。

注：如果try-catch中执行了return语句，那么finally子语句仍然会被执行。try-catch语句执行了程序退出代码，即执行System.exit(0);则不执行finally子语句。

常用的实用类

String类（是一个final类，不能扩展也不能有子类）

String类来创造一个字符串变量，字符串变量是对象。字符串常量是对象，把字符串常量的引用（内存中的地址）赋值给一个字符串变量。

public int length()获取一个字符串的长度。

public boolean equals(String s)比较当前字符串的实体是否与参数指定字符串s的实体相同。

public boolean equalsIgnoreCase(String s)比较当前字符串对象与参数s指定字符串是否相同，比较时忽略大小写。

public boolean startsWith(String s)、public booleanendsWith(String s)判断当前字符串对象的前缀是否是参数s指定的字符串;判断一个字符串的后缀是否是字符串s。

public int compareTo(Sring s)按字典序与参数s指定的字符串比较大小，相同返回值为0;大于字符串s,返回正值;如果小于s,返回负值。（public int compareToIgnoreCase(Sring s)忽略大小写）

public boolean contains(String s)当前字符串对象是否还有s指定的字符串。

public int indexOf(String s)字符串的索引位置从0开始。从头检索字符串s，并返回首次出现字符串s的索引的位置，没检索到返回值为-1。indexOf(String s,int startpoint)从startpoint开始检索;lastIndexOf(Strings)从当前字符串头开始检索。

public String Substring(int startpoint)获得一个从startpoint截取的子串;substring(intstart,int end)获得从start开始到end-1的一个子串。

public String trim()获得一个字符串对象，该字符串对象是s去掉前后空格后的字符串。

public static  +具体的数据类型(首字母不大写)+  parse数据类型（第一个字母大写）（Strings） throws NumberFormatException(byte int short long float double)把字符串转换成基本数据类型

public static String valueOf(数据类型 n)( byteshort long float double)

注意：在字符串中，需要用转义运算”\\”来表示”\”。

 

 

 

组件及事件处理

图形用户界面（Graphics User Interface,GUI）

Java的java.awt包，即java抽象窗口工具包（AbstractWindow Toolkit,AWT）

容器类（Container）和组件类（Component）

Javax.swing包中JComponent类是java.awt包中Container类的一个直接子类是java.awt包中Component类的一个间接子类。

Java把Component类的子类或间接子类创建的对象称为一个子类。

Java把Container类的子类或间接子类创建的对象称为一个子类。

可以向容器中添加组件。一个容器可以调用public add()方法将容器添加到组件中。

容器调用removeAll()方法移除容器中的所有组件，调用remove(Component c)移除容器中参数为c的指定组件。

容器本身是一种组件，可以嵌套。

每当给容器添加或移除组件时，应该让容器调用validate()方法，以保证容器中的组件能正确显示出来。