Java简单复习

Java

1.JVM

　　Java 虚拟机 Java 虚拟机（Java virtual machine，JVM）是运行 Java 程序必不可少的机制。JVM实现了Java语言最重要的特征：即平台无关性。原理：编译后的 Java 程序指令并不直接在硬件系统的 CPU 上执行，而是由 JVM 执行。JVM屏蔽了与具体平台相关的信息，使Java语言编译程序只需要生成在JVM上运行的目标字节码（.class）,就可以在多种平台上不加修改地运行。Java 虚拟机在执行字节码时，把字节码解释成具体平台上的机器指令执行。因此实现java平台无关性。它是 Java 程序能在多平台间进行无缝移植的可靠保证，同时也是 Java 程序的安全检验引擎（还进行安全检查）。

　　 JVM 是 编译后的 Java 程序（.class文件）和硬件系统之间的接口 （ 编译后：javac 是收录于 JDK 中的 Java 语言编译器。该工具可以将后缀名为. java 的源文件编译为后缀名为. class 的可以运行于 Java 虚拟机的字节码。）

2.Java版本

　　Java ME：Java ME以往称作J2ME（Java Platform, Micro Edition）是为机顶盒、移动电话和PDA之类嵌入式消费电子设备提供的Java语言平台，包括虚拟机和一系列标准化的Java API。它和Java SE、Java EE一起构成Java技术的三大版本，并且同样是通过JCP（Java Community Process）制订的。
　　Java SE：J2SE，标准版的Java平台是一个Java2的平台，为用户提供一个程序开发环境。这个程序开发环境提供了开发与运行Java软件的编译器等开发工具、软件库及Java虚拟机。它也是Java2平台、企业版本和Java网页服务的基础。
　　Java EE：Java EE，Java平台企业版（Java Platform Enterprise Edition），是Sun公司为企业级应用推出的标准平台。Java平台共分为三个主要版本Java EE、Java SE和Java ME。
Sun公司在1998年发表JDK1.2版本的时候，使用了新名称Java 2 Platform，即“Java2平台”，修改后的JDK称为Java 2 Platform Software Developing Kit，即J2SDK。并分为标准版（Standard Edition，J2SE），企业版（Enterprise Edition，J2EE），微型版（MicroEdition，J2ME）。J2EE便由此诞生。
　　2005年6月，JavaOne大会召开，SUN公司公开Java SE 6。此时，Java的各种版本已经更名以取消其中的数字“2”：J2EE更名为Java EE, J2SE更名为Java SE，J2ME更名为Java ME。随着Java技术的发展，J2EE平台得到了迅速的发展，成为Java语言中最活跃的体系之一。现如今，J2EE不仅仅是指一种标准平台，它更多的表达着一种软件架构和设计思想。

3.Java标识符命名规则与规范

规则

  1. 标识符由大小写字母, 下划线, 数字, $符号组成.
  2. 开头可以是大小写字母, 下划线, 和$符号(数字和其他符号不能开头)
  3. 标识符长度没有限制
  4. 标识符不能是关键子和保留字

规范

  1. 标识符的命名最好能反映出其作用
  2. java语言对字母的大小写有严格的要求
  3. 所有自定义标识符需全部遵循标识符的命名规范 
变量
  1. 如果是单个单词, 单词全部字母小写. 如:int count;
  2. 如果是由多个单词组成的复合单词, 除第一个单词外, 其后所有单词首字母大写. 如: int sumScore; 
常量
  1. 常量所有单词字母大写, 如果是由多个单词组成, 由下划线连接.如: String PERSON_NAME; 
方法
  1. 方法命名规范与变量相似, 如 count(); getSum(); 
类
  1. 类名的所有单词首字母均大写. 如Person{} , DataCenter{}; 
包
  1. 用小写的倒置域名来命名. 格式: 前缀 + 项目名 + 模块名 + 层如: org.itfuture.domain.sorts

4.Java关键词

关键字含义
abstract表明类或者成员方法具有抽象属性
assert用来进行程序调试
boolean基本数据类型之一，布尔类型
break提前跳出一个块
byte基本数据类型之一，字节类型
case用在switch语句之中，表示其中的一个分支
　　
catch用在异常处理中，用来捕捉异常
char基本数据类型之一，字符类型
class类
const保留关键字，没有具体含义
continue回到一个块的开始处
default默认，例如，用在switch语句中，表明一个默认的分支
do用在do-while循环结构中
double基本数据类型之一，双精度浮点数类型
else用在条件语句中，表明当条件不成立时的分支
enum枚举
extends表明一个类型是另一个类型的子类型，这里常见的类型有类和接口
final用来说明最终属性，表明一个类不能派生出子类，或者成员方法不能被覆盖，或者成员域的值不能被改变
finally用于处理异常情况，用来声明一个基本肯定会被执行到的语句块
float基本数据类型之一，单精度浮点数类型
for一种循环结构的引导词
goto保留关键字，没有具体含义
if条件语句的引导词
implements表明一个类实现了给定的接口
import表明要访问指定的类或包
instanceof用来测试一个对象是否是指定类型的实例对象
int基本数据类型之一，整数类型
interface接口
long基本数据类型之一，长整数类型
native用来声明一个方法是由与计算机相关的语言（如C/C++/FORTRAN语言）实现的
new用来创建新实例对象
null用来标识一个不确定的对象
package包
private一种访问控制方式：私用模式
protected一种访问控制方式：保护模式
public一种访问控制方式：共用模式
return从成员方法中返回数据
short基本数据类型之一,短整数类型
static表明具有静态属性
strictfp用来声明FP_strict（单精度或双精度浮点数）表达式遵循IEEE 754算术规范
super表明当前对象的父类型的引用或者父类型的构造方法
switch分支语句结构的引导词
synchronized表明一段代码需要同步执行
this指向当前实例对象的引用
throw抛出一个异常
throws声明在当前定义的成员方法中所有需要抛出的异常
transient声明不用序列化的成员域
try尝试一个可能抛出异常的程序块
void声明当前成员方法没有返回值
volatile
　　		表明两个或者多个变量必须同步地发生变化
while
　　		用在循环结构中
　　

5.数据类型与所占字节

　　Java基本类型共有八种，基本类型可以分为三类，字符类型char，布尔类型boolean以及数值类型byte、short、int、long、float、double。数值类型又可以分为整数类型byte、short、int、long和浮点数类型float、double。JAVA中的数值类型不存在无符号的，它们的取值范围是固定的，不会随着机器硬件环境或者操作系统的改变而改变。实际上，JAVA中还存在另外一种基本类型void，它也有对应的包装类 java.lang.Void，不过我们无法直接对它们进行操作。8 中类型表示范围如下： 

byte：8位，最大存储数据量是255，存放的数据范围是-128~127之间。
short：16位，最大数据存储量是65536，数据范围是-32768~32767之间。
int：32位，最大数据存储容量是2的32次方减1，数据范围是负的2的31次方到正的2的31次方减1。
long：64位，最大数据存储容量是2的64次方减1，数据范围为负的2的63次方到正的2的63次方减1。
float：32位，数据范围在3.4e-45~1.4e38，直接赋值时必须在数字后加上f或F。
double：64位，数据范围在4.9e-324~1.8e308，赋值时可以加d或D也可以不加。  
boolean：只有true和false两个取值。
char：16位，存储Unicode码，用单引号赋值。

表2
类型字节表示范围包装类
byte(字节型)1-128~127Byte
short(短整型)2-32768～32767 Short
int(整型)4-2147483648～2147483647Integer
long(长整型)8-9223372036854775808 ~ 9223372036854775807Long
float(浮点型)4-3.4E38～3.4E38Float
double(双精度型)8-1.7E308～1.7E308Double
char(字符型)2从字符型对应的整型数来划分，其表示范围是0～65535 Charater
booealn(布尔型)1true或falseBoolean

6.常量和变量的表示

常量

　　常量代表程序运行过程中不能改变的值。
　　常量在程序运行过程中主要有2个作用：
　　　　1. 代表常数，便于程序的修改（例如：圆周率的值）
　　　　2. 增强程序的可读性（例如：常量UP、DOWN、LEFT和RIGHT分辨代表上下左右，其数值分别是1、2、3和4）
　　常量的语法格式和变量类型，只需要在变量的语法格式前面添加关键字final即可。在Java编码规范中，要求常量名必须大写。
　　则常量的语法格式如下：
　　　　final 数据类型 常量名称 = 值；
　　　　final 数据类型 常量名称1 = 值1， 常量名称2 = 值2，……常量名称n = 值n；
　　例如： 

final double PI = 3.14；  
final char MALE=‘M’，FEMALE=‘F’；

在Java语法中，常量也可以首先声明，然后再进行赋值，但是只能赋值一次，示例代码如下： 

final int UP；  
UP = 1；

注意：

　　成员变量会被系统默认初始化，局部变量没这功能，所以必须自己初始化。
还要注意静态成员变量也没系统默认初始化，必须在初始化块或者定义时或者构造函数里进行手动初始化。

7.类型转换的特殊形式

Java类型转换

8.Math类常用方法

  1. static double random() 返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。
  2. static long round(double a) 返回最接近参数的 long。
  3. abs 返回绝对值

9.使用Scanner类注意方式引入的包

import java.util.Scanner;  
Scanner scanner = new Scanner(System.in);

10.Break、continue、Return

  1. break:跳出当前的循环，如果是嵌套只跳出本层
  2. continue:跳过本次进行下次循环
  3. return：结束函数

11.类的结构

public class className{
      //全局变量
   public static void main(String[] args) {
      //局部变量
      //函数体
  }
  //函数
  private int fun(){
    return 1;
  }
}

12.对象的创建和初始化

类名 变量名 = new 类构造函数();
类名 变量名1；
变量名1 = new 类构造函数();

13.静态初始化块与非静态初始化块

　　静态初始化块:使用static定义,当类装载到系统时执行一次.若在静态初始化块中想初始化变量,那仅能初始化类变量,即static修饰的数据成员.
　　非静态初始化块:在每个对象生成时都会被执行一次,可以初始化类的实例变量.
　　非静态初始化块会在构造函数执行时,且在构造函数主体代码执行之前被运行.
括号里的是初始化块，这里面的代码在创建Java对象时执行，而且在构造器之前执行！
　　其实初始化块就是构造器的补充，初始化块是不能接收任何参数的，定义的一些所有对象共有的属性、方法等内容时就可以用初始化块了初始化！！
　　好处是可以提高初始化块的复用，提高整个应用的可维护性。 

 public class TestInitiateBlock {

 {
   System.out.println("In non-static initialization block!");
 };

 static {
    System.out.println("In static initialization block!");
 };

 public TestInitiateBlock() {
   System.out.println("In Constructor1!");
 }

 public void show() {
    System.out.println("In show()!");
 }

 public static void main(String[] args) {
   TestInitiateBlock ti = new TestInitiateBlock();
   ti.show();
 }
}

运行结果:  
In static initialization block!  
In non-static initialization block!  
In Constructor1!  
In show()!

14.局部变量使用前，先初始化

　　局部变量详相当于在学校的学号或者公司的工号，只有去了学校或公司才有。而全局变量相当于你的姓名，在出生时或出生之前就有了。

15.适配器

　　Java中的适配器实际就是实现接口的类，只不过这个类中的方法都是空方法，当你需要使用哪个方法时，只需在方法种添加相应过程。

16.Awt

　　AWT 是Abstract Window ToolKit (抽象窗口工具包)的缩写，这个工具包提供了一套与本地图形界面进行交互的接口。AWT 中的图形函数与操作系统所提供的图形函数之间有着一一对应的关系，我们把它称为peers。 也就是说，当我们利用 AWT 来构件图形用户界面的时候，我们实际上是在利用操作系统所提供的图形库。由于不同操作系统的图形库所提供的功能是不一样的，在一个平台上存在的功能在另外一个平台上则可能不存在。为了实现Java语言所宣称的”一次编译，到处运行”的概念，AWT 不得不通过牺牲功能来实现其平台无关性，也就是说，AWT 所提供的图形功能是各种通用型操作系统所提供的图形功能的交集。由于AWT 是依靠本地方法来实现其功能的，我们通常把AWT控件称为重量级控件。

17.Swing

　　Swing 是在AWT的基础上构建的一套新的图形界面系统，它提供了AWT 所能够提供的所有功能，并且用纯粹的Java代码对AWT 的功能进行了大幅度的扩充。例如说并不是所有的操作系统都提供了对树形控件的支持， Swing 利用了AWT 中所提供的基本作图方法对树形控件进行模拟。由于 Swing 控件是用100%的Java代码来实现的，因此在一个平台上设计的树形控件可以在其他平台上使用。由于在Swing 中没有使用本地方法来实现图形功能，我们通常把Swing控件称为轻量级控件。
　　AWT和Swing之间的基本区别：AWT 是基于本地方法的C/C++程序，其运行速度比较快；Swing是基于AWT 的Java程序，其运行速度比较慢。对于一个嵌入式应用来说，目标平台的硬件资源往往非常有限，而应用程序的运行速度又是项目中至关重要的因素。在这种矛盾的情况下，简单而高效的AWT 当然成了嵌入式Java的第一选择。而在普通的基于PC或者是工作站的标准Java应用中，硬件资源对应用程序所造成的限制往往不是项目中的关键因素，所以在标准版的Java中则提倡使用Swing， 也就是通过牺牲速度来实现应用程序的功能。
通俗的话:
　　AWT 是抽象窗口组件工具包，是 java 最早的用于编写图形节目应用程序的开发包。Swing 是为了解决 AWT 存在的问题而新开发的包，它以 AWT 为基础的。

18.Swing引入的包

import javax.swing.*;//注意是 javax

19.顶层容器JFrame、jDialog、japplet

　　JFrame:用来设计类似于Windows系统中的窗口形式的应用程序。
　　JDialog:和JFrame类似，只不过JDialog是用来设计对话框。
　　JApplet:用来设计可以在嵌入在网页中的Java小程序。

20.窗体、容器的默认布局

　　Frame是框架，这个是要实现的功能界面的布局，默认管理器“BorderLayout”；

　　Panel是面板，这个是要实现的某个功能模块的具体实现，默认管理器“FlowLayout“；
　　1. BorderLayout:将版面划分成东、西、南、北、中五个区域，将添加的组件按指定位置放置。-java.awt.BorderLayout
　　2. FlowLayout:组件按从左到右而后从上到下的顺序依次排列，一行不能放完则折到下一行。-java.awt.FlowLayout
　　3. GridLayout:矩形网格形式对容器的组件进行布置-java.awt.GridLayout
　　4. GridBagLayout:GridBagLayout以表格形式布置容器内的组件，将每个组件放置在每个单元格内，而一个单元格可以跨越多个单元格合并成一个单元格，即多个单元格可以组合成一个单元格，从而实现组件的自由布局。-java.awt.GridBagLayout
　　5. CardLayout:以层叠的方式布置组件，如同很多张卡片叠在一起，从而只能看到最上面的那一张卡片。-java.awt.CardLayout
　　6. BoxLayout:以嵌套式盒子来管里容器的布局，通过将组件放入水平或垂直形盒子以多层嵌套的方式进行布局。-javax.swing.BoxLayout

21.Event事件，事件源，事件监听，事件处理

　　1.event object：事件状态对象，用于listener的相应的方法之中，作为参数，一般存在与listerner的方法之中
　　2.event source：具体的事件源，比如说，你点击一个button，那么button就是event source，要想使button对某些事件进行响应，你就需要注册特定的listener。
　　3.event listener：对每个明确的事件的发生，都相应地定义一个明确的Java方法。这些方法都集中定义在事件监听者（EventListener）接口中，这个接口要继承 java.util.EventListener。 实现了事件监听者接口中一些或全部方法的类就是事件监听者。
　　伴随着事件的发生，相应的状态通常都封装在事件状态对象中，该对象必须继承自java.util.EventObject。事件状态对象作为单参传递给应响应该事件的监听者方法中。发出某种特定事件的事件源的标识是：遵从规定的设计格式为事件监听者定义注册方法，并接受对指定事件监听者接口实例的引用。
　　具体的对监听的事件类，当它监听到event object产生的时候，它就调用相应的方法，进行处理。

22.加监听、常用事件监听

Button awtButton = new Button();            //import java.awt.Button;
    JButton swingButton  =new JButton(); 　　//import javax.swing.JButton;

    awtButton.addActionListener(new ActionListener() {
        @Override
        public void actionPerformed(ActionEvent e) {
            // TODO Auto-generated method stub

        }
    });

23.网络编程相关类

针对网络通信的不同层次，Java提供的网络功能有四大类：InetAddress 、URLs、Sockets、Datagram
1、InetAddress面向的是网络层（IP层），用于标识网络上的硬件资源。
2、 URL面向的应用层，通过URL，Java程序可以直接送出或读入网络上的数据。
3、 Sockets和Datagram面向的则是传输层。Sockets使用的是TCP协议，这是传统网络程序最常用的方式，可以想象为两个不同的程序通过网络的通信信道进行通信。Datagram则使用UDP协议，是另一种网络传输方式，它把数据的目的地纪录在数据包中，然后直接放在网络上。

24.设计模式：策略模式

//抽象折扣类

public interface MemberStrategy {
/**
 * 计算图书的价格
 * @param booksPrice    图书的原价
 * @return    计算出打折后的价格
 */
   public double calcPrice(double booksPrice);
}

//初级会员折扣类

public class PrimaryMemberStrategy implements MemberStrategy {

@Override
public double calcPrice(double booksPrice) {

    System.out.println("对于初级会员的没有折扣");
    return booksPrice;
  }
}

//中级会员折扣类

public class IntermediateMemberStrategy implements MemberStrategy {

@Override
public double calcPrice(double booksPrice) {

    System.out.println("对于中级会员的折扣为10%");
    return booksPrice * 0.9;
 }
}  
//高级会员折扣类  

public class AdvancedMemberStrategy implements MemberStrategy {
@Override
public double calcPrice(double booksPrice) {

    System.out.println("对于高级会员的折扣为20%");
    return booksPrice * 0.8;
  }
 }  
//价格类(相当于上下文)  
public class Price {
   //持有一个具体的策略对象
    private MemberStrategy strategy;
/**
 * 构造函数，传入一个具体的策略对象
 * @param strategy    具体的策略对象
 */
public Price(MemberStrategy strategy){
    this.strategy = strategy;
}

/**
 * 计算图书的价格
 * @param booksPrice    图书的原价
 * @return    计算出打折后的价格
 */
public double quote(double booksPrice){
    return this.strategy.calcPrice(booksPrice);
  }
}  
//客户端:  

public class Client {
public static void main(String[] args) {
    //选择并创建需要使用的策略对象
    MemberStrategy strategy = new AdvancedMemberStrategy();
    //创建环境
    Price price = new Price(strategy);
    //计算价格
    double quote = price.quote(300);
    System.out.println("图书的最终价格为：" + quote);
  }
 }

25.中介者模式

abstract class AbstractColleague {
protected int number;

public int getNumber() {
    return number;
}

public void setNumber(int number){
    this.number = number;
}
//注意这里的参数不再是同事类，而是一个中介者
public abstract void setNumber(int number, AbstractMediator am);
}

class ColleagueA extends AbstractColleague{

public void setNumber(int number, AbstractMediator am) {
    this.number = number;
    am.AaffectB();
 }
}

class ColleagueB extends AbstractColleague{

@Override
public void setNumber(int number, AbstractMediator am) {
    this.number = number;
    am.BaffectA();
 }
}

abstract class AbstractMediator {
protected AbstractColleague A;
protected AbstractColleague B;

public AbstractMediator(AbstractColleague a, AbstractColleague b) {
    A = a;
    B = b;
}

public abstract void AaffectB();

public abstract void BaffectA();

}
class Mediator extends AbstractMediator {

public Mediator(AbstractColleague a, AbstractColleague b) {
    super(a, b);
}

//处理A对B的影响
public void AaffectB() {
    int number = A.getNumber();
    B.setNumber(number*100);
}

//处理B对A的影响
public void BaffectA() {
    int number = B.getNumber();
    A.setNumber(number/100);
 }
}

public class Client {
public static void main(String[] args){
    AbstractColleague collA = new ColleagueA();
    AbstractColleague collB = new ColleagueB();

    AbstractMediator am = new Mediator(collA, collB);

    System.out.println("==========通过设置A影响B==========");
    collA.setNumber(1000, am);
    System.out.println("collA的number值为："+collA.getNumber());
    System.out.println("collB的number值为A的10倍："+collB.getNumber());

    System.out.println("==========通过设置B影响A==========");
    collB.setNumber(1000, am);
    System.out.println("collB的number值为："+collB.getNumber());
    System.out.println("collA的number值为B的0.1倍："+collA.getNumber());

 }
}

26.异常处理

　　　对于可能出现异常的代码，有两种处理办法：
第一、在方法中用try…catch语句捕获并处理异常，catach语句可以有多个，用来匹配多个异常。例如： 

public void p(int x){
 try{
  ...
 }catch(Exception e){
  ...
 }finally{
  ...
 }
}

第二，对于处理不了的异常或者转型异常，用throws抛出

public void test1() throws MyException{//抛出产生的异常
 ...
 if(....){
  throw new MyException();//用于产生异常
  }
}

27.数组的使用

  1. 声明一个数组

Java代码 

String[] aArray = new String[5];  
String[] bArray = {"a","b","c", "d", "e"};  
String[] cArray = new String[]{"a","b","c","d","e"};
  1. 输出一个数组

Java代码 

int[] intArray = { 1, 2, 3, 4, 5 };  
String intArrayString = Arrays.toString(intArray);  

// print directly will print reference value  
System.out.println(intArray);  
// [I@7150bd4d  

System.out.println(intArrayString);  
// [1, 2, 3, 4, 5]
  1. 从一个数组创建数组列表

Java代码 

String[] stringArray = { "a", "b", "c", "d", "e" };  
ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(stringArray));  
System.out.println(arrayList);  
// [a, b, c, d, e]
  1. 检查一个数组是否包含某个值

Java代码 

String[] stringArray = { "a", "b", "c", "d", "e" };  
boolean b = Arrays.asList(stringArray).contains("a");  
System.out.println(b);  
// true
  1. 连接两个数组

Java代码 

int[] intArray = { 1, 2, 3, 4, 5 };  
int[] intArray2 = { 6, 7, 8, 9, 10 };  
// Apache Commons Lang library  
int[] combinedIntArray = ArrayUtils.addAll(intArray, intArray2);
  1. 声明一个内联数组（Array inline）

Java代码 

method(new String[]{"a", "b", "c", "d", "e"});
  1. 把提供的数组元素放入一个字符串

Java代码 

// containing the provided list of elements  
// Apache common lang  
String j = StringUtils.join(new String[] { "a", "b", "c" }, ", ");  
System.out.println(j);  
// a, b, c
  1. 将一个数组列表转换为数组

Java代码 

String[] stringArray = { "a", "b", "c", "d", "e" };  
ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(stringArray));  
String[] stringArr = new String[arrayList.size()];  
arrayList.toArray(stringArr);  
for (String s : stringArr)  
System.out.println(s);
  1. 将一个数组转换为集（set）

Java代码 

Set<String> set = new HashSet<String>(Arrays.asList(stringArray));  
System.out.println(set);  
//[d, e, b, c, a]
  1. 逆向一个数组

Java代码 

int[] intArray = { 1, 2, 3, 4, 5 };  
ArrayUtils.reverse(intArray);  
System.out.println(Arrays.toString(intArray));  
//[5, 4, 3, 2, 1]
  1. 移除数组中的元素

Java代码 

int[] intArray = { 1, 2, 3, 4, 5 };  
int[] removed = ArrayUtils.removeElement(intArray, 3);//create a new array  
System.out.println(Arrays.toString(removed));
  1. 将整数转换为字节数组

Java代码 

byte[] bytes = ByteBuffer.allocate(4).putInt(8).array();  

for (byte t : bytes) {  
   System.out.format("0x%x ", t);  
}

28.equals与==

java中的数据类型，可分为两类：
1.基本数据类型，也称原始数据类型。
　　byte,short,char,int,long,float,double,boolean
　　他们之间的比较，应用双等号（==）,比较的是他们的值。
2.复合数据类型(类)
　　当他们用（==）进行比较的时候，比较的是他们在内存中的存放地址，所以，除非是同一个new出来的对象，他们的比较后的结果为true，否则比较后结果为false。
　　 JAVA当中所有的类都是继承于Object这个基类的，在Object中的基类中定义了一个equals的方法，这个方法的初始行为是比较对象的内存地 址，但在一些类库当中这个方法被覆盖掉了，如String,Integer,Date在这些类当中equals有其自身的实现，而不再是比较类在堆内存中的存放地址了。
　　对于复合数据类型之间进行equals比较，在没有覆写equals方法的情况下，他们之间的比较还是基于他们在内存中的存放位置的地址值的，因为Object的equals方法也是用双等号（==）进行比较的，所以比较后的结果跟双等号（==）的结果相同。

29.线程

　　Java多线程实现方式主要有三种：继承Thread类、实现Runnable接口、使用ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值，只有最后一种是带返回值的。
1、继承Thread类实现多线程
继承Thread类的方法尽管被我列为一种多线程实现方式，但Thread本质上也是实现了Runnable接口的一个实例，它代表一个线程的实例，并且，启动线程的唯一方法就是通过Thread类的start()实例方法。start()方法是一个native方法，它将启动一个新线程，并执行run()方法。这种方式实现多线程很简单，通过自己的类直接extend Thread，并复写run()方法，就可以启动新线程并执行自己定义的run()方法。例如： 

public class MyThread extends Thread {
　　 public void run() {
　　 System.out.println("MyThread.run()");
　　  }
   }

2、实现Runnable接口方式实现多线程
如果自己的类已经extends另一个类，就无法直接extends Thread，此时，必须实现一个Runnable接口，如下：

public class MyThread extends OtherClass implements Runnable {
　　public void run() {
　　 System.out.println("MyThread.run()");
　　}
}

为了启动MyThread，需要首先实例化一个Thread，并传入自己的MyThread实例： 

MyThread myThread = new MyThread();
Thread thread = new Thread(myThread);
thread.start();

事实上，当传入一个Runnable target参数给Thread后，Thread的run()方法就会调用target.run()，参考JDK源代码 

public void run() {
　　if (target != null) {
　　 target.run();
　　}
}

30.内部类

本文标题:Java简单复习

文章作者:Quincy

发布时间:2016-12-17, 21:29:51

最后更新:2016-12-18, 23:39:53

原始链接:hubaoquan.github.io/2016/12/17/Java/Java简单复习/

许可协议: "署名-非商用-相同方式共享 4.0" 转载请保留原文链接及作者。

文章目录
  1. 1. 1.JVM
  2. 2. 2.Java版本
  3. 3. 3.Java标识符命名规则与规范
    1. 3.1. 规则
    2. 3.2. 规范
  4. 4. 4.Java关键词
  5. 5. 5.数据类型与所占字节
  6. 6. 6.常量和变量的表示
    1. 6.1. 常量
    2. 6.2. 注意：
  7. 7. 7.类型转换的特殊形式
  8. 8. 8.Math类常用方法
  9. 9. 9.使用Scanner类注意方式引入的包
  10. 10. 10.Break、continue、Return
  11. 11. 11.类的结构
  12. 12. 12.对象的创建和初始化
  13. 13. 13.静态初始化块与非静态初始化块
  14. 14. 14.局部变量使用前，先初始化
  15. 15. 15.适配器
  16. 16. 16.Awt
  17. 17. 17.Swing
  18. 18. 18.Swing引入的包
  19. 19. 19.顶层容器JFrame、jDialog、japplet
  20. 20. 20.窗体、容器的默认布局
  21. 21. 21.Event事件，事件源，事件监听，事件处理
  22. 22. 22.加监听、常用事件监听
  23. 23. 23.网络编程相关类
  24. 24. 24.设计模式：策略模式
  25. 25. 25.中介者模式
  26. 26. 26.异常处理
  27. 27. 27.数组的使用
  28. 28. 28.equals与==
  29. 29. 29.线程
  30. 30. 30.内部类
|