简单

与平台无关

多线程

面向对象

每个平台都会有自己独特的机器指令。

机器指令就是可以被平台直接识别、执行的一种由0、1组成的序列代码。

java虚拟机的核心是字节码指令，它也是一种机器指令。

相同CPU和不同的操作系统所形成平台的机器指令可能是不同的。

类

对象

源文件

方法

Java SE

java EE

java ME

以上都不适合

如果源文件中有多个类，那么只能有一个类是public类。

源文件的名字必须与public类的名字完全相同，扩展名是java。

源文件中必须有一个主类。

Java语句用区分大小写。

源文件包含多个类，编译源文件时将生成多个class文件。

Java应用程序总是从主类的main方法开始执行。

Java解释器执行的类名必须是主类的名字，并且没有扩展名。

Java应用程序中的多个源文件，可以只编译含有主类的源文件。

public类

主类

任一类

第一个类

中国

$123

ONE-two

b_1

null不是关键字，可以作为标识符。

hello和Hello是相同的标识符。

标识符的第一个字符不能是_.

语法上允许用中文作为标识符。

System

new

main

true

float a=1.0;

char a=97;

int a=123L;

byte a=-129

System.out.print("你好，很高兴认识你")；

System.out.println("你好，很高兴认识你")；

System.out.printf("你好，很高兴认识你")；

System.out.print("你好，

可以使用Scanner类创建对象reader，然后再用reader调用方法。

输入整型数据时，可以使用reader对象调用hasNextInt（）方法。

等待用户输入新的数据时会发生堵塞，按enter键可以解除堵塞。

reader对象可以用空格、回车作为分隔符。

int s=30;

int [10]s;

int b=new int[4];

int [ ]a,b表示声明一个整型数组和一个整型变量b。

数组c的首地址

数组c的引用

123

1，2，3

[1,2,c]

[2,3,c]

[2,3,99]

[1,2,99]

[2,3,4]

[1,2,3]

[1,2,3,4]

[2,3,4,5]

"int [ ]a,b[ ];"声明了一个int型一维数组a和一个int型二维数组b。

“float a[20];”是正确的数组声明。

“boolean yes=flase；”是正确的boolean变量声明。

1e2和2.05E2都是double型常量。

System是关键字

_class可以作为标识符

char型字符再Unicode表中的位置范围是0~65535

对于“int a[ ]=new int[3];”,a.length的值是3

true

default

_int

good-class

float foo=1；

float foo=1.0；

float foo=2e1；

float foo=2.02；

float foo=1e2；

float foo=3.14；

float foo=3.03d；

float foo=0x0123；

char ch=“R”；

char ch=‘\\’；

char ch=‘ABCD’；

char ch="ABCD"；

对于“int a[ ][ ]=new int[6][4];",a.length的值是6

对于“int a[ ][ ]=new int[2][9];",a.length、a[0].length、a[1].length的值都是9

对于“int [ ]a=new int[3];”,a[0]、a[1]、a[2]的值都是0

对于“int [ ][ ]a={{1,2,3},{4,5,6,7}};”,a[1].length的值是4

5.0/2+10的结果是double型数据

（int）5.8+1.0的结果是int型数据

'苹'+‘果’的结果是char型数据

（short）10+'a'的结果是short型数据

public class E {

public static void main(String args[ ]){

int m=10,n=0;

while(【代码】){

n++}

}

}

m-->0

m++>0

m=0

m>100&&true

public class Test {

public static void main(String args[ ]){

boolean boo =false;

if(boo = true){

System.out.print("hello");

System.out.print("你好");

}

else {

System. out.print("ok" );

System. out.print("yes" );

}

}

}

出现编译错误

程序的输出结果是hello你好

程序的输出结果是ok

程序的输出结果是okyes

n%10

n/10%10

n/100%10

n/1000%10

public class Test {

public static void main(String args[ ]){

int m = 0;

if(【代码】){

System.out.println("您好");

}

else{

System.out.println("hello" );

}

}

}

m--<=0

++m>0

m++>0

--m<0

class Dog{

Dog(int m){ }

Dog( double m){ }

int Dog( int m){

return 23;}

void Dog(double m){ }

}

Dog(int m)与 Dog(double m)互为重载的构造方法。

int Dog(int m)与 void Dog(double m)互为重载的非构造方法,

Dog 类只有两个构造方法,而且没有无参数的构造方法。

Dog 类有3个构造方法。

1.为成员变量分配内存,并指定默认值。

1.计算出一个引用值。

1.执行构造方法。

1.为成员变量分配内存,并指定默认值。

public class Test {

public static void main(String args[ ]){

Tom cat = new Tom();}

}

class Tom{

void Tom( ){

System.out.println("ok");}

Tom(int m){

System.out.println("你好");}

}

程序运行时输出:ok。

没有构造方法。

有编译错误,因为创建对象cat使用的不是构造方法,java编译器已经不提供默的构造方法了。

程序运行时无任何输出

成员变量有默认值

this可以出现在static方法中

类中的实例方法可以用类名调用

局部变量也可以用访问修饰符 public、proteced、private 修饰

源文件可以有两条包语句(package)

源文件不可以有多条import 语句

如果源文件有package语句,该语句也可以是源文件的第2条语句

类中的类方法(static方法)只能操作类变量(static变量),不可以操作实例变量

class E {

int x;

public void f(int n){

int m; //A

int t = x+n; //B

int y=x+m; //C

m= 10;

y = x+m;} //D

}

pubic clasa People{

int m=10,n; //A

n=200; //B

void f( ){

if(m==n)

n=++m; //C

else

n=n-m; //D

}

}

A

B

C

D

interface Com{

int MAX;

public void stop( );

void start( );

abstract void loop( );}

“void start( );”会导致编译出错

“public void stop( );”会导致编译出错。

“abstract void loop( );”会导致编译出错

“int MAX;”会导致编译出错

public int f( ){

int f( ){

public double f( ){

public abstract int f( );

public float getNum( ){return 4.0f;}

public void getNum( ){ }

public void getNum(double d) { }

public double getNum(float d){return 4. 0d ; }

final类不可以有父类

可以用new运算符和abstract类的构造方法创建对象

如果一个类中有abstract方法,这个类必须是 abstract类

static方法也可以同时是abstract方法

cat instanceof B的值是 true

bird instanceof A 的值是 true

bird instanceof C的值是 true

cat instanceof A 的值是 true

final 类不可以有子类

abstract类中只可以有abstract 方法

abstract 类中可以有非 abstract方法,但该方法不可以用 final 修饰

final修饰的方法可以重写

匿名类没有构造方法。

匿名类只有一个不带参数的构造方法(编译器会给匿名类一个名字和构造方法）

匿名类一定是final类

匿名类一定是内部类

非匿名内部类也可以有(内部)子类

内部类不可以是final类

不可能用匿名类声明对象,但可以直接用匿名类创建一个对象

匿名子类(和子类有关的匿名类)可以继承父类的方法,也可以重写父类的方法

内部类的外嵌类的成员变量在内部类中仍然有效

内部类中的方法也可以调用外嵌类中的方法

内部类的类体中可以声明类变量(statie)

外嵌类的类体中可以用内部类声明对象,作为外嵌类的成员