欢迎指正。
word/media/image1.gifjava 标识符是区分大小写的
（1）标识符包括字母、数字、下划线、$
（2）其中字母为广义的，Unicode所有字符，汉字等各国文字
（3）源文件名与public类名可以不相同
（4）源文件其扩展名为.jar（小编学的是压缩包名）
word/media/image2.gifmain方法头的合法是
public static void main(String args[]){}
3. java Applieation 源程序的主类是指包含：
含main函数的类
4. java 的字符编码集为Unicode编码
5.import:导入包
Java.io.*;不知道他要考什么
6.final:
根据程序上下文环境，Java关键字final有“这是无法改变的”或者“终态的”含义，它可以修饰非抽象类、非抽象类成员方法和变量。你可能出于两种理解而需要阻止改变：设计或效率。
final类不能被继承，没有子类，final类中的方法默认是final的。 final方法不能被子类的方法覆盖，但可以被继承。 final成员变量表示常量，只能被赋值一次，赋值后值不再改变。 final不能用于修饰构造方法。 注意：父类的private成员方法是不能被子类方法覆盖的，因此private类型的方法默认是final类型的。
static
static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态static代码块，但是Java语言中没有全局变量的概念。1. 静态方法 通常，在一个类中定义一个方法为static，那就是说，无需本类的对象即可调用此方法
声明为static的方法有以下几条限制： · 它们仅能调用其他的static 方法。 · 它们只能访问static数据。 · 它们不能以任何方式引用this 或super
2. 静态变量
声明为static的变量实质上就是全局变量。当声明一个对象时，并不产生static变量的拷贝，而是该类所有的实例变量共用同一个static变量。静态变量与静态方法类似。所有此类实例共享此静态变量，也就是说在类装载时，只分配一块存储空间，所有此类的对象都可以操控此块存储空间，当然对于final则另当别论了
static和final一块用表示什么 static final用来修饰成员变量和成员方法，可简单理解为“全局常量”！ 对于变量，表示一旦给值就不可修改，并且通过类名可以访问。 对于方法，表示不可覆盖，并且可以通过类名直接访问。
package 打包
访问限定修饰符：
7.
最终方法final class A{}，这样定义的类A就是最终类，最终类不可被继承，也就是说不能写这样的代码，class B extends A{}了
final void B(){}，这样定义的方法就是最终方法，最终方法在子类中不可以被重写，也就是说，如果有个子类继承这个最终方法所在的类，那么这个子类中就不能再出现void B(){}这样的方法了。但是可以重载，也就是说可以出现void B(int a){}。
代码示例
public class Main
{
public static void main (String[] args) {
Oak o=new Oak();
o.develop();
}
}
class tree
{
public final void develop()
{
System.out.println("树在生长");
}
}
final class Oak extends tree
{
/*public void develop(){}
*这样写是错误的，不能重写
*/
public void develop(int a)
{
}
//这样写可以，可以重载
}
/*
class willow extends Oak{}
这样写也是错误的，最终类不可被继承
*/
静态方法 上一题已介绍
代码
public class Main
{
public static void main (String[] args) {
//非静态方法调用
//Oak o=new Oak();
//o.develop();
//静态方法调用
Oak.develop();
}
}
class tree
{
public static void develop()
{
System.out.println("树在生长");
}
}
抽象方法
抽象方法 就 是以abstract修饰的方法，这种方法是不完整的；仅有声明而没有方法体。如：
abstract void f();
当一个子类继承某个抽象类时，它可以有两个选择：
部分实现或完全不实现父类的所有抽象方法，但此时子类必须声明为抽象类。
实现父类所有的抽象方法，此时之类不比声明为抽象类。
包含抽象方法的类叫做“抽象类 ”。如果一个类包含一个或多个抽象方法，该类必须被限定为抽象的。（否则，编译器就会报错。）
抽象类不能被实例化（be instantiated)，但可以实例化非抽象子类。
代码;考试题
abstract class Shape{
public abstract double Area( );//抽象方法
}
class Circle extends Shape
{
double r;
Circle(double r)
{
this.r=r;
}
public double Area( ) //实例化
{
return 3.14*r*r;
}
}
class Triangle extends Circle
{
double h;
Triangle(double h,double d)
{
super(d); //继承底
this.h=h; //高
}
public double Area( )
{
return r*h/2.0;
}
}
class Trapezoid extends Triangle
{
double u; //上底
Trapezoid(double u,double d,double h)
{
super(d,h);
this.u=u;
}
public double Area( )
{
return (u+r)*h/2.0;
}
}
public class Main
{
public static void main (String[] args)
{
Circle c=new Circle(1);
System.out.println("圆形面积为："+c.Area( ));
Triangle t=new Triangle(1,2);
System.out.println("三角形面积为："+t.Area( ));
Trapezoid tz=new Trapezoid(1,2,3);
System.out.println("梯形形面积为："+tz.Area( ));
}
}
8.无需在程序中导入的包是：java.lang;
9. 表示没理解，直接复制了博客内容
覆盖：子类重写父类的方法，要求方法名和参数类型完全一样(参数不能是子类)，返回值和异常比父类小或者相同(即为父类的子类)，访问修饰符比父类大或者相同。
覆盖是对于实例方法而言的
方法不能交叉覆盖：子类实例方法不能覆盖父类的静态方法；
子类的静态方法也不能覆盖父类的实例方法(编译时报错)
隐藏：父类和子类拥有相同名字的属性或者方法（ 方法隐藏只有一种形式，就是父类和子类存在相同的静态方法）时，父类的同名的属性或者方法形式上不见了，实际是还是存在的。
隐藏是对于静态方法和成员变量（静态变量和实例变量）而言的
（1）当发生隐藏的时候，声明类型是什么类，就调用对应类的属性或者方法，而不会发生动态绑定
（2） 属性只能被隐藏，不能被覆盖
（3）变量可以交叉隐藏：子类实例变量/静态变量可以隐藏父类的实例/静态变量
3、隐藏和覆盖的区别
（1）被隐藏的属性，在子类被强制转换成父类后，访问的是父类中的属性
在无强制转换时子类要访问父类的属性使用super关键字
（2）被覆盖的方法，在子类被强制转换成父类后，调用的还是子类自身的方法
子类要是想访问父类的方法，可以使用super关键字
RTTI(run time type identification，运行时类型检查)
RTTI只针对覆盖，不针对隐藏：因为覆盖是动态绑定，是受RTTI约束的，隐藏不受RTTI约束
运行时类型为引用变量所指向的对象的类型，编译时类型是引用变量自身的类型
public class Test {
public static void main(String[] args) {
Circle circle = new Circle();//本类引用指向本类对象
Shape shape = new Circle();//父类引用指向子类对象(会有隐藏和覆盖)
System.out.println(circle.name);
circle.printType();
circle.printName();
//以上都是调用Circle类的方法和引用
System.out.println(shape.name);//调用父类被隐藏的name属性
shape.printType();//调用子类printType的方法
shape.printName();//调用父类隐藏的printName方法
}
}
class Shape {
public String name = "shape";
public Shape(){
System.out.println("shape constructor");
}
public void printType() {
System.out.println("this is shape");
}
public static void printName() {
System.out.println("shape");
}
}
class Circle extends Shape {
public String name = "circle"; //父类属性被隐藏
public Circle() {
System.out.println("circle constructor");
}
//对父类实例方法的覆盖
public void printType() {
System.out.println("this is circle");
}
//对父类静态方法的隐藏
public static void printName() {
System.out.println("circle");
}
}
重载 方法名相同，参数不同
1.方法名必须相同。 2.方法的参数类型和参数个数两者至少有一不同。 (参数为子类也算不同。 int 和Integer也算不同，都算重载)3.方法的修饰符和返回值类型可以不同。
代码:
void f(int x) {
…
}
void f(int x, int y) {
…
}
void f(int x, String s) {
…
}
10.interface是声明一个接口时的标识符
实现接口用implements。
接口是为了多重继承
A extends B A、B可以是接口也可以是类
A implements B A 是类B是接口
11.java Applet 不知道要干什么，自己看书吧
12.
thread多线程类 java.lang
void start()：启动线程，JVM调用该线程的run()方法使其与其他的线程并发运行。
init()初始化
resume()方法就是将一个挂起线程复活继续执行
void run()：如果线程是通过实现Runnable接口的对象构造，则调用该Runnable对象的run()方法；否则该方法不执行任何操作并返回。Thread的子类应重写该方法。
13.
数组名如同对象名一样是一种引用
14.
在Java程序中定义的类有两种成员：成员变量、成员方法
15.
Java的图像处理功能被封装在Image
16.创建一个名为MyPackage包的语句是
package MyPackage;
17.
一个基于Swing的应用程序可能在任何平台上都会有相同的外观与风格。
18.
面向对象的四个特性
抽象：把客观事物用代码抽象出来，包括两种抽象：第一种是数据抽象，也就是对象的属性。第二种是过程抽象，也就是对象的行为特征。
封装：把客观事物封装成抽象的类，对不可信的对象隐藏，对可信的对象或者类进行操作。
继承：对着父类进行继承extends，implements实现接口。
多态：允许不同类的对象对同一消息做出响应。方法的重载、方法的继承就是体现这一关系。
19.
什么是异常，举例说明异常情况
异常通常指，你的代码可能在编译时没有错误，可是运行时会出现异常。比如常见的空指针异常。也可能是程序可能出现无法预料的异常，比如你要从一个文件读信息，可这个文件不存在，程序无法运行下去了，故程序要抓这些异常，通过异常处理机制来抛出这些异常，程序员就可以通过抛出的异常来修改代码。try{}catch{}finally{}try块中放入可能会出现异常的代码，catch块负责捕获异常，finally块负责处理一些必须执行的代码，比较关闭流等。
20.通过构造方法建立文件流对象，创建输入输出文件流对象的两种常用构造方法。
FileInputStream(String name)
FileInputStream(File filename)
FileOutputStream(String name)
FileOutputStream(File filename)
21.。
public class Main
{
public static void main (String[] args) {
int a[][]={{1,2},{3,4,5}};
for(int i=0;i<2;i++)
{
for(int j=0;j<3;j++)
{
System.out.print(a[i][j]+" ");
}
System.out.println();
}
}
}
运行结果
1 2 Exception in thread "main" java.lang.IndexOutOfBoundsException: 2
at Main.main(Main.java:9)
答案
修改标红处代码
for(int j=0;j<a[i].length;j++)
解析
由于数组每一行元素个数不同，导致数组越界异常。
用使用 数组名.length返回数组元素个数，从而判断循环次数。
22.
class A
{
private int a=10;
int getA()
{
return a;
}
}
public class Main extends A
{
int b=100;
public static void main (String[] args)
{
Main ab=new Main();
int i,j;
//__________________
//__________________
System.out.println("i="+i);
System.out.println("j="+j);
}
}
答案：
i=ab.getA();
j=ab.b;
解析
一个类继承自另一个类那么继承他所有非私有（不是private）变量和方法，用法 子类对象名.方法/变量名 即i=ab.getA();
类A中的a是private所以不能用i=ab.a;
普通成员变量调用：对象名.成员变量名。即j=ab.b;
23
public class Main{
static int x=1;
int y=0;
Main()
{
x++;
y++;
}
public static void main (String[] args)
{
Main st=new Main();
System.out.println("x="+x);
System.out.println("st.y="+st.y);
}
}
运行结果
x=2
st.y=1
解析：
我也不知道他要干什么
24.
*******
*******
*******
*******
代码：
public class Main{
public static void main (String[] args)
{
for(int i=0;i<4;i++)
{
for(int j=0;j
{
System.out.print(" ");
}
System.out.println("*******");
}
}
}
本文来源：https://www.2haoxitong.net/k/doc/eaf27a2abf1e650e52ea551810a6f524cdbfcb0a.html
文档为doc格式