Java小笔记

---

1: 面向对象编程

1.1： 封装性

1.2： 继承性

1.3： 多态性

2：命名规范

2.1：类名

类的名字要符合标识符的规定，即名字可以由字母、下划线、数字或美元符号组成，并且第一个字符不能是数字,在给类命名时要体现下列编程风格：

（1）如果类名使用拉丁字母，那么名字的首字母使用大写字母，如Hello，Time和Dog等

（2）类名最好容易识别、见名知意。当类名由几个单词复合而成时，每个单词的首字母使用大写，如BeijingTime、HelloChina等

2.2：变量名

变量的名字除了符合标识符规定外，名字的首单词的首字母使用小写，如果变量的名字由多个单词组成，从第2个单词开始的其他单词的首字母使用大写，而且变量名字见名知意

2.3：方法名

同变量名

3：了解new

3.1：new+构造方法创建对象的过程

1. 为成员变量和方法分配内存空间并初始化成员变量的值（成员变量有默认值）P74
2. 执行构造方法中的语句
3. 计算引用值（即new A()是一个值）
4. 对象诞生

类声明对象的时候是不会分配内存的，

class Student{

…

}

Student zhangSan

//此时并不分配内存

只有使用new创建对象的时候才会分配内存给对象的成员变量和方法例如Student zhangSan=new Student()，除此之外，new Student()还会作为一个引用（地址）赋值给 zhangSan。

4：类和对象

4.1：类

类是体现封装的一种数据类型（封装着数据和对数据的操作）类体分为两部分，变量的声明和方法的定义。

4.2： 对象

用类声明的变量被称为对象。

注意：

1. 实体是内存空间，对象是引用。

4.2.1： 构造方法

格式要求：

1. 名字与类名相同
2. 无类型(无类型是指无数据类型，而不是不可以被public等修饰)

默认的构造方法

如果类中没有编写构造方法，系统会默认该类只有一个构造方法该默认的构造方法是无参数的，且方法体中没有语句。P72

自定义构造方法

如果类中定义了一个或多个构造方法，那么Java不提供默认的构造方法。P72

4.3：类变量类方法和实例变量实例方法

上图为Java应用程序的开发步骤

注意点：

1. 加了关键字static修饰的是类

2. 类方法只可以使用类相关的（方法，变量），main方法也不例外，实例方法都可以使用P71

3. 语句块{}内的为局部变量，局部变量包含语句块内的声明的变量和方法参数

4. 类中属性部分为成员变量

5. 类变量创建的对象共享内存，类变量的内存空间直到程序退出运行，才释放所占有的内存。（可通过类名操作类变量，创建的对象也可以操作）

6. 类变量和类方法在字节码加载入内存就可以通过类名调用，不需要创建对象（如果一个方法不需要操作实例成员变量就可以实现某种功能，就可以考虑将这样的方法声明为类方法，可以避免创建对象浪费内存）

7. 同一名字，在方法体中局部变量大于成员变量。（成员变量的隐藏）

8. 对成员变量的操作只能放在方法中。P70

9. 成员变量有默认值而局部变量没有默认值（区别）。P76

10. 成员变量在整个类中的所有方法中都有效，其有效性与其在类体中声明的位置无关

11. 局部变量只在声明它的方法内有效：方法参数在整个方法内有效；方法内的局部变量从声明它的位置之后开始有效（与位置有关）

解释：

7：

//正确
class A{
	int a = 12;
	float b = 12.56f;
}

//错误
class A{
    int a;
    float b;
    a = 12;		//非法，这是赋值语句（语句只能出现在方法体中），不是变量声明
    b = 12.56f; //非法
}

5: 多态

java中存在两种多态。即重载和重写。

5.1：重载

一个类中可以有多个方法相同的名字，但这些方法的参数必须不同，即或者是参数的个数不同，或者是参数的类型不同。（方法的返回类型和参数的名字不参与比较）P69

Example_1:

class Square{
    int highSide;
    int lowSide;
    Square(){
        System.out.println("这是一个正方形");
    }
    Square(int highSide,int lowSide){
        this.highSide=highSide;
        this.lowSide=lowSide;
        System.out.println("这是一个面积为"+lowSide*highSide+"的正方形");
    }

}
public class Example {
    public static void main(String[] args) {
        Square square_1=new Square();
        Square square_2=new Square(5,5);
    }
}

5.2： 重写

方法重写是指在子类中定义一个方法，这个方法的类型和父类的方法类型一致，并且这个方法的名字、参数个数、参数类型、和父类的方法完全相同。（只是方法体不同）

6： 引用类型参数传值

Java的引用类型数据包括前面刚刚学习的对象，数组，以及后面学习的接口。当参数是引用类型时，“传值”传递的是变量中存放的“引用”，而不是变量所引用的实体。

7：this关键字

this是Java的一个关键字，表示某个对象。this可以出现在实例方法和构造方法中，但不可以出现在类方法中。在构造方法中，this代表使用该构造方法所创建的对象。

7.1： 在实例方法中使用this

实例方法操成员变量中的实例变量：

成员变量

实例方法操作成员变量中的类变量：

类名.类变量名

但是当成员变量与局部变量同名时需：

this.成员变量

实例方法操作类方法或实例方法：

方法

8：垃圾收集机制

Java运行环境的垃圾收集发现堆中分配的实体不再被任何对象所引用时，就会释放该实体在堆中占用的内存。

9： 包

包是Java语言中管理类的一个机制。不同Java源文件中可能出现名字相同的类，如果想区分这些类，就需要使用包名。

9.1： 包语句

package 包名

package语句必须作为Java源文件的第一条语句。（源文件至多可以有一条package语句）如果源程序中省略了package语句，则认为源文件所属包为无名包，只要这些类放在相同的目录中那么他们就属于同一个包，但没有包名。

包名可以是一个合法的标识符，也可以是若干个标识符加“.”分隔而成。

9.2： import语句

一个类想要使用的那个类和它不在一个包中，它怎样才能使用这样的类呢？这正是import语句要解决的内容。

一个Java源程序中可以有多个import语句，他们必须写在package语句和源文件中类的定义之间

引入一个包中的所有类，可以用通配符”*“，例如：

import java.util.*;

表示引入java.util包中的所有类，而

import java.util.Date;

只是引入java.until包中的Date类

9.3： 避免类名混淆

P103

这里的测试代码未能成功验证

9.3.1： 区分无包名和有包名的类

①如果一个源文件使用了一个无名包中的A类，同时又用import语句引入了某个有包名的同名的类，就可能引起类名的混淆。当使用A类时，如果省略包名，那么源文件使用的是有包名中的A类。要想同时使用无名包和有名包中的A类就不能省略包名

②如果源文件使用通配符”*“引入了包中所有的类当使用A类时，那么源文件使用的是无名包中的A类。要想同时使用无名包和有名包中的A类就不能省略包名。

9.3.2： 区分有名包类

如果一个源文件引入了两个包中同名的类，那么在使用该类时，不允许省略包名。

10： 访问权限

​ P104

访问限制修饰符有private、protected和public，他们都是Java的关键字，用来修饰**成员变量或方法**

10.1： private

对于私有成员变量或方法，只有在本类中创建该类的对象时，这个对象才能访问自己的私有成员变量和类中的私有方法。不可被继承。

10.2： public

在任何一个类中用类创建了一个对象之后，该对象能访问自己的public变量和public方法。

10.3： protected

在类A中用类B创建了一个对象后，如果类A与类B在同一个包中，那么该对象能访问自己的protected变量和protected方法。如果类X使用类D创建了一个对象，如果类D的对象的protexted成员变量或protected方法是从父类继承的，那么要一直追溯到该protected成员变量或方法的“祖先类”，即A类。如果X类和A类在同一个包中，那么对象能访问继承的protected变量和方法

10.4: 友好

在类A中用类B创建了一个对象后，如果类A与类B在同一个包中，那么该对象能访问自己的友好变量和友好方法。子类和父类不在同一个包中则不可继承

注意点：如果子类和父类不在同一个包中，那么，子类继承了父类的protected、public成员变量做为子类的成员变量，并且继承了父类的protected、public方法为子类的方法。如果子类和父类不在同一个包里，子类不能继承父类的友好变量和友好方法。

10.5： public类与友好类

class前加public关键字为public类。

class前不加关键字则为友好类。

注意点：

1. 友好类在另外一个类中使用友好类创建对象时要保证他们在一个包中。
2. 不能用protected和private修饰类。

11： 继承

注意点：

1. Java不支持多重继承（子类只能有一个父类）
2. 继承的成员变量或方法的访问权限保持不变
3. 私有变量与方法与友好型变量与方法与受保护变量和方法

11.1: 子类对象的构造过程

P128

当用子类的构造方法创建一个子类的对象时，子类的构造方法总是先调用父类的某个构造方法。也就是说，如果子类的构造方法没有明显地指明使用父类的哪个构造方法，子类就调用父类不带参数的构造方法。因此，当用子类创建对象时，不仅子类中声明的成员变量被分配了内存（初始化变更且被继承），而且父类的成员变量也都被分配了内存。但是着并不浪费，子类对象调用继承的方法可以操作这些未被子类继承却分配了内存空间的变量。

11.2：成员变量的隐藏

只要子类中声明的成员变量和继承的父类中的成员变量同名，子类就隐藏了继承的成员变量。

11.3：super关键字

P133

子类可以隐藏从父类继承的成员变量和方法，如果在子类中想使用被子类隐藏的成员变量或方法，可以使用关键字super。

11.3.1：使用super调用父类的构造方法

子类不继承父类的构造方法，因此，子类如果想使用父类的构造方法，必须在子类的构造方法中使用关键字super来表示，而且super必须是子类构造方法的头一条语句。

需要注意的是，如果在子类的构造方法中，没有明显地写出super关键字来调用父类的某个构造方法，那么默认有super()语句，即调用父类的不带参数的构造方法。

如果类中定义了一个或多个构造方法，那么Java不提供默认的构造方法（不带参数的构造方法）。因此当在父类中定义多个构造方法时，应当包括一个不带参数的构造方法，以防子类省略super时出现错误

11.3.2：使用super操作被隐藏的成员变量和方法

当子类创建一个对象时，除了子类声明的成员变量和继承的成员变量要分配内存外（这些内存单元是属于子类对象的），被隐藏的成员变量也要分配内存，但该内存单元不属于任何对象，这些内存单元必须用super调用。同样，当子类创建了一个对象时，除了子类声明的方法和继承的方法要分配入口地址外（这些方法可供子类对象调用)，被隐藏的方法也要分配入口地址，但该入口地址只对super可见，所以必须有super调用。当super调用隐藏的方法时,该方法中出现的成员变量是指被隐藏的成员变量（所以使用隐藏方法之前，往往对隐藏的成员变量初始化）（子类和父类的成员变量和方法重名导致隐藏）

12： final关键字

12.1: final类

final类不能被继承，即不能有子类

12.2: final方法

如果用final修饰父类中的一个方法，那么这个方法不允许子类重写（不会被隐藏）。

12.3： 常量

如果成员变量或局部变量被修饰为final，就是常量。常量在声明时没有默认值，所以在声明常量时必须指定该常量的值，而且不能发生变化。

13： 对象的上转型对象

P137

假设A类是B类的父类，当用子类创建一个对象，并且把这个对象的引用放到父类的对象中。

上转型变量会失去原对象的一些属性和功能（上转型对象相当于子类对象的一个“简化”对象）：

①：上转型对象不能操作子类新增的成员变量，不能调用子类新增的方法。

②：上转型对象可以访问子类继承或隐藏的成员变量，也可以调用子类继承的方法或子类重写的方法（如果子类重写了父类的静态方法[static方法]，那么子类对象的上转型对象不能调用子类重写的静态方法，只能调用父类的静态方法）

以上两点总结就是：要和父类有关才可以调用

13.1：继承与多态

当一个类有很多子类，并且这些子类都重写了父类中的某个方法时，把子类创建的对象的引用放到一个父类的对象中，就得到了该对象的一个上转型对象。这个上转型对象在调用这个方法时可能具有多种形态，因为不同的子类再重写父类的方法时可能产生不同的行为。多态性是指父类的某个方法被其子类重写时，可以各自产生自己的功能行为。

14: abstract类和方法

P140

14.1： abstract类

abstract类可以有abstract方法（也可以没有）也可以有非abstract方法。但是非abstract类中不可以有abstract方法

abstract类中可以有成员变量

14.2： abstract方法

abstract方法只允许声明，不允许实现（无方法体），而且不允许使用final和abstract同时修饰一个方法

14.3： 理解

①：对于abstract类，不能使用new运算符创建该类的对象。

②：如果一个非abstract类是abstract类的子类，他必须重写父类的abstract方法（去掉abstract修饰并给出方法体），如果一个abstract类是abstract类的子类，它可以重写父类的abstract方法也可以继承父类的abstract方法。

③：抽象类可以抽象出重要的行为标准，该行为标准用抽象方法来表示。即抽象类封装了子类必须有的行为标准；abstract类可以声明诺若干个abstract方法，表明这些方法在整个一同设计的重要性。

④：抽象类声明的对象可以成为其子类的对象的上转型对象。

15：接口

P146

Java不支持多继承，但支持一个类可以实现多个接口。

15.1: 接口体

注意点：

1. 接口体中所有的权限均为public，所以抽象方法允许省略public，abstract修饰符，而static常量允许省略public，final和static修饰符。(接口中可以省略public，但是实现其的类中不可以)
2. 不可以定义default的static方法，default的实例方法和通常的普通方法比就是用关键字default修饰的带方法体的实例方法。并且不可以省略default关键字，因为接口中不允许定义通常的带方法体的实例方法。
3. 不可用static和abstract同时修饰一个方法（因为static可以直接调用，而abstract是没实现的，即没有方法体）

15.2: 接口的实现

如果一个关键字实现了某个接口，那么这个类自然拥有了接口中的常量和default方法（去掉了default关键字），该类也可以重写接口中的default方法（注意，重写时需要去掉default关键字）。如果一个非abstract类实现了某个接口，那么这个类必须重写该接口的所有abstract方法，即去掉abstract修饰给出方法体。如果一个abstract类实现了某个接口，该类可以选择重写接口的abstract方法或直接拥有接口的abstract方法。

简单来说：abstract必须重写，而default方法则可继承可重写

注意：

1. 类实现某接口，但类不拥有接口的static方法
2. 接口中方法的访问权限都是public，重写时不可省略public（否则就降低了访问权限）
3. 接口可被public型和友好型。public接口可以被任何一个类声明实现。友好接口可以被与该接口在同一包中的类声明实现。
4. 接口中abstract方法无法实现所以不用写{}
5. 接口可继承接口，由于访问权限都是public所以为全方面继承。
6. 接口回调的子类不可以有新增的成员变量和方法

15.3： 接口回调

接口回调是指可以把实现某一接口的类创建的对象的引用赋给给接口声明的接口变量中，那么该接口变量就可以调用被类重写的接口方法以及接口中的default方法。

15.4： 接口与多态

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

15.5： abstract类与接口的比较

子类除了需要实现父类的abstract方法，还需要从父类继承一些变量或继承一些重要的非abstract方法，就可以考虑用abstract类。如果某个问题不需要继承，只是需要若干个类给出某些重要的abstract方法的实现细节，就可以考虑使用接口。

16：几种特殊类

16.1：内部类

Java除了了成员变量和方法，还允许有一种成员，即内部类。

内部类和外嵌类之间的重要关系如下：

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

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

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

④：非内部类不可以是static类

16.2：匿名类

16.3: 和类有关的匿名类

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

加黑色People是类，那么下列代码就是用People类的一个子类（匿名类）创建的对象：

new People(){        //子类创建对象时就是使用父类的构造方法，只不过匿名类无名字无法声明
    匿名类的类体
};

因此，匿名类可以继承父类的方法，也可以重写父类的方法。使用匿名类时必然是在某个类中直接用匿名类创建对象，因此，匿名类一定是内部类，匿名类可以访问外嵌类中的成员变量和方法，匿名类的类体不可以声明static成员变量和static方法。

尽管匿名类创建的对象没有经过类声明步骤，但匿名对象的引用可以传递给一个匹配的参数，匿名类的常用方法是向方法的参数传值。

16.4：和接口有关的匿名类

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

new 接口名(){
    实现接口的匿名类的类体
};

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

16.3：异常类

所谓异常就是程序运行时可能出现一些错误，例如试图打开一个根本不存在的的文件等，异常处理将会改变程序的控制流程，让程序有机会对错误作出处理。

Java的异常经常出现在方法调用过程中，即在方法调用过程中抛出异常对象，导致程序运行出现异常，并等待处理。

16.3.1: try…catch语句

Java使用try…catch语句来处理异常，将可能出现的异常操作放在try…catch语句的try部分，当try部分中的某个方法调用发生异常后，try部分将立刻结束执行，而转向执行相应的catch部分；所以程序可以将发生异常后的处理放在catch部分。try…catch语句可以由几个catch组成，分别处理发生的相应异常。

try

包含可能发生异常的语句，即可能throw关键字抛出了异常对象。

catch

各个catch参数中的异常类都是Exception的某个子类，表明try部分可能发生的异常。

16.3.2: 自定义异常类

我们也可以扩展Exception类定义自己的异常类，然后规定哪些方法产生这样的异常。一个方法在声明时可以使用**throws关键字声明要产生的若干个异常，并在该方法的方法体中具体给出产生异常的操作，即用相应的异常类创建对象，并使用throw**关键字抛出该异常对象，导致方法结束执行。程序必须在try…catch块语句中调用能发生异常的方法，其中catch的作用就是铺货throw方法抛出的异常对象。

注意：throw时Java的关键字，该关键字的作用就是抛出异常。throw和throws是两个不同的关键字

格式和具体执行过程请见P167

简要过程：方法throws声明可能发生的异常→try中throw抛出异常对象（new EException(b)）→catch（EException e）捕获异常→执行自定义异常的语句（自定义的异常要继承Exception）

17：正则表达式

17.1：底层实现原理

Pattern pattern = Pattern.compile(regex);		//创建模式对象[即正则表达式对象]
Matcher matcher = pattern.matcher(str);		    //创建匹配器

matcher.find()方法完成的任务（未分组）：

1. 根据指定的规则，定位满足规则的字符串
2. 找到后，将字符串的开始的下标记录到matcher对象的属性 int[] groups; groups[0]=0,把该字符串的结束的下标+1的值记录到groups[1]中。
3. 同时记录oldLast的值为groups[1]，即下次执行matcher.find()时，就从oldLast开始匹配

源码：

public String group(int group) {
        if (first < 0)
            throw new IllegalStateException("No match found");
        if (group < 0 || group > groupCount())
            throw new IndexOutOfBoundsException("No group " + group);
        if ((groups[group*2] == -1) || (groups[group*2+1] == -1))
            return null;
        return getSubSequence(groups[group * 2], groups[group * 2 + 1]).toString();//!!!主要这句
    
    	//regex="\\D\\D\\D\\D",当int group接收的值为0时则分别得到groups[0]和groups[1],根据groups[0]和group[1]所记录的位置输出字符串.第二次指向的时候会重新赋值groups[0],groups[1]。
    	//regex="(\\D\\D)(\\D\\D)",()表示分组，第一个()表示第一组....。groups[0]为匹配到的字符串的起始下标，groups[1]为匹配到的字符串(整个字符串)结束的下标+1，groups[2]为第一组起始下标,groups[3]为第一组结束下标+1；groups[4]为第二组...。当int group接收到的值为1时,得到groups[2],groups[3]即为第一组的字符串。
    }

18：UML

如果类的名字是常规字形，则表明该类是具体类；如果类的名字是斜体字行则表明该类是抽象类或者为接口

泛化关系（继承）：实线空三角（起始端是子类，终点端是父类）

关联关系：实线实三角（A类的成员变量是用B类来声明的，起始端是A类）

依赖关系：虚线实三角（A类某个方法的参数用B类来声明或者A类某个方法返回的数据类型是B类型的，起始端是A类）

实现关系：虚线空三角（起始端是实现借口的子类）

19：组件和事件编程

定义监视器：监视器实现ActionListener接口，重写actionPerformed方法（参数为ActionEvent e）

创建监听器

添加监听器：addActionListener()

20：线程

当JVM加载代码，发现main方法之后，会启动一个线程，这个线程成为“主线程”，该线程负责执行main方法。那么在main方法的执行中在再创建的线程，就成为程序中的其他线程。如果main方法中没有创建其他线程，那么当main方法执行完最后一个语句，即main方法返回时，JVM就会结束Java应用程序。如果main方法中又创建了其他线程，那么JVM就要在主线程和其他线程之间轮流切换，以保证每个线程都有机会使用CPU资源，main方法即使执行完最后的语句（主线程结束），JVM也不会结束程序，JVM一直要等到程序中的所有线程都结束之后才会结束Java应用程序。

①：新建状态

当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于new状态，称作新建状态。此时他已经有了相应的内存空间和其他资源。即尚未启动（没有调用start（）方法）的线程处于此状态

②：可运行状态

处于NEW状态的线程，必须调用Thread类提供的start（）方法，进入RUNNABLE状态，称为可运行状态。处于NEW状态的线程仅仅是占有了内存资源，在JVM管理的线程中还没有这个线程，此线程必须调用start（），让自己进入RUNNABLE状态，这样JVM就会知道又有一个新线程排队等待切换。当JVM将CPU使用权切换给RUNNABLE状态的线程时，如果线程是Thread的子类创建的，该类中的run（）方法立马执行。所以我们必须在子类中重写父类的run（）方法，Thread类中的run（）方法没有具体的内容，子类要重写以覆盖父类的run（）方法。

使用Runnable也可以创建线程对象

21：设计模式

▲小知识点

1. 方法里面不可以再嵌套方法

2. 接口中abstract，static，public均可以省略（接口中是静态常量不可以在子类中改变static final）

3. abstract和final不可以同时修饰，static和abstract不可以同时修饰

4. final类不能被继承，无子类。final方法不允许子类重写。final常量一定要指定一个值，且不可修改

5. 子类继承的方法所操作的成员变量一定是被子类继承或隐藏的成员变量

6. 子类不继承父类的构造方法

7. 构造函数不可以用final修饰

8. 类体中不可以有除成员变量声明和方法定义外其他操作

9. 关系运算符和逻辑运算符的结果都是布尔型

10. byte short char int long float double

11. 高精度和低精度的运算结果取高精度,然后不可以在赋给低精度变量

12. while和if括号内表达式的值均为布尔型

13. 标识符由字母、下画线、美元符号和数字组成，并且第一个字符不能是数字字符，标识符不能是关键字

14. default,true,false不可以做为标识符

15. main不是java的关键字

16. char 型变量内存提供两个字节，必须使用单引号，特殊字符要转义，范围为0_{65535，可以将0}65535内的数字赋给字符变量（输出仍为字符）

17. float声明时，后面必须有后缀f或F(和double区分，double的d或者D可以省略)

float area = 1e1	//错误
float foo = 2		//正确，向下兼容，可以自动转换
float foo = 0X0123	//正确，向下兼容，可以自动转换。级别高的值赋给级别低的值要显示转换

1. byte型变量的取值范围为-2^7~27-1（-128~127）

byte amount = 128	//错误

1. int a[][]=new int[2][9]		//a.length=2;a[0].length=a[1].length=9
   

2. 数组声明时不能给具体范围 （int a[20]错误）

3. boolean yes =true（不能写成TRUE）

4. int[] a,b[]		//a为一维数组，b为二维数组，int[]是对整体
   

6. 含有main方法的类称为主类，应用程序总是从主类开始执行（运行主类的字节码）

7. 主方法（主类）至少一个，公共类至多一个，文件名与公共类一致，主类不一定要是公共类

8. java程序可以没有public类，但是最多只能有一个

9. 如果源文件包含多个类，编译源文件将生成多个扩展名为class的文件，每个扩展名是class的文件只存放一个类的字节码，其文件名与该类的名字相同

10. 如何输出多个变量的值而不是输出变量的和：

System.out.println(a+b+c);       //×
System.out.println(""+a+b+c);    //√

11. java中double输出只能用%lf，而c中double用scanf输入只能用%lf，输出%lf，%f都可以。（float只用%f）
    正确，向下兼容，可以自动转换。级别高的值赋给级别低的值要显示转换

1. byte型变量的取值范围为-2^7~2^7-1（-128~127）

```java
byte amount = 128	//错误

1. int a[][]=new int[2][9]		//a.length=2;a[0].length=a[1].length=9
   

2. 数组声明时不能给具体范围 （int a[20]错误）

3. boolean yes =true（不能写成TRUE）

4. int[] a,b[]		//a为一维数组，b为二维数组，int[]是对整体
   

6. 含有main方法的类称为主类，应用程序总是从主类开始执行（运行主类的字节码）

7. 主方法（主类）至少一个，公共类至多一个，文件名与公共类一致，主类不一定要是公共类

8. java程序可以没有public类，但是最多只能有一个

9. 如果源文件包含多个类，编译源文件将生成多个扩展名为class的文件，每个扩展名是class的文件只存放一个类的字节码，其文件名与该类的名字相同

10. 如何输出多个变量的值而不是输出变量的和：

System.out.println(a+b+c);       //×
System.out.println(""+a+b+c);    //√

11. java中double输出只能用%lf，而c中double用scanf输入只能用%lf，输出%lf，%f都可以。（float只用%f）