Java期末考复习

System.out是PrintStream类，System.out是PrintStream类!System.out是PrintSystem类！！！！！！！！！!！！！！！！！！！！！！
System.in是InputStream类。三个标准XX里，只有in是InputStream,另外两个都是PrintStream类！！！！！！！

一、12年考题

主要盲点：System.out、URL的组成、网络协议的种类、final变量、向下转型
主要易错点：类变量（牵一发而动全局）

1.final全局变量必须要手动初始化，要么在声明时就赋初值，要么在类的构造方法里面赋初值，或者在构造代码块里赋初值；final局部变量只需要在使用前初始化就可以了。为什么需要手动赋初值呢？因为如果不手动赋初值的话，就是虚拟机给它赋值0了，但是让机器来给咱们一个0没啥意义啊。另外final变量赋了值以后就不能再更改，也就是不能再赋值了。

2.接口中变量的默认修饰符是public static final（对修改关闭），方法的默认修饰符是public abstract（对扩展开放）。只有接口能继承接口

3.类变量：无论类实例化了多少个对象，类都只拥有一份类变量。也就是说，无论我们是通过哪个对象，或者是类来修改类变量，最后所有对象的类变量的值保留的都是最后一次修改后的值：

package G12;

public class IdentifyMyParts {
   
    public static int x=7;
    public int y=3;
    public static void main(String[] args){
   
        IdentifyMyParts a=new IdentifyMyParts();
        IdentifyMyParts b=new IdentifyMyParts();
        a.y=5;
        b.y=6;
        a.x=1;
        b.x=2;
        System.out.println("a.y="+a.y);
        System.out.println("b.y="+b.y);
        System.out.println("a.x="+a.x);
        System.out.println("b.x="+b.x);
        System.out.println("class.x="+IdentifyMyParts.x);
    }
}

输出为：

4.子类.getclass().equals(父类.getclass())的返回结果是false，但是子类 instanceof 父类的返回结果是true

package G12;

interface one{
   }

class Two implements one{
   }

class Two_sub extends Two{
   }

public class Test {
   
    public static void main(String[] args){
   
        one test1=new Two();
        Two_sub ts=new Two_sub();
        System.out.println(ts instanceof Two);
        System.out.println(ts.getClass().equals(test1.getClass()));

    }
}

返回结果：

instanceof和getclass的区别：S(Object) instanceof T(Class) instanceof判断对象S是否为类T或其子类的实例；getclass则返回运行时该对象的类。需要指出一点，父类进行向下转型以后，运行时调用getclass方法得到的就是子类了，也就是相当于父类在以子类的身份运行、示人。

5.URL基本格式：

protocol：//hostname:port/resourcename#anchor

1）protocol使用的协议：可以是http,ftp,news,telnet等
2）hostname:主机名，指定域名服务器（DNS）能访问到的WWW服务的计算机，例如www.sun.com
3）port：可选
4）resourcename：资源名，是主机上能访问到的目录或文件
5）anchor:标记，可选，指定文件中有特定标记的位置
综上，一个合法的URL应该至少由以下5个部分组成：
协议+双斜线+主机名+单斜线+资源名

6.System.out.println()详解（两个包：lang+io,两个final）：
1）System是Java.lang包中的一个final类

public final class System

2）out是System类的静态final成员字段，类型为PrintStream

public static final PrintStream out

3）PrintStream是一个位于java.io下的类

public class PrintStream extends FilterOutputStream

4）println是printStream类的一个方法(修饰符是public void)，下面是其中一个：

public void println() {
   
        newLine();
    }
//这个方法告诉我们System.out.println()是不会报错的，但是System.out.println(null)
//就会报错

但是print没有定义无参的方法，所以直接写System.out.print()是会报错的。总结一下就是：

7.Button组件的大小不会随框架大小变化而变化的布局方式是FlowLayout布局
1）GridLayout:网格布局，将每个组件放置在rows行及columns列中，即将容器分成大小相等的矩形域，当一排满了，就从下一行开始
2）BorderLayout:边界布局，将组件按东南西北中五种方位放置在容器中。如果东南西北某个位置上没有放置组件，则该区域会被中间区域和相关的某个位置区域自动充满
3）FlowLayout:顺序布局，每个部件从左到右，从上到下，依据容器的大小逐行在容器中顺序摆放。这种布局方式是Applet,Panel,JPanel类的默认布局方式

8.父类直接向下转型成子类时，编译时编译器不会去管你到底是哪个类型，所以编译时不会不错；但是运行时就会出错了，因为到了运行的时候就真的得看类到底有没有相关功能了。比如下面这段代码，编译时不报错，运行时会报错：

package G12;

class Base{
   }

class Sub extends Base{
   }

class Sub2 extends Base{
   }

public class T1_11 {
   
    public static void main(String[] args){
   
        Base b=new Base();
        Sub s=(Sub)b;
        System.out.println("everything is ok");
    }
}

报错信息为：

Exception in thread "main" java.lang.ClassCastException: G12.Base cannot be cast to G12.Sub
	at G12.T1_11.main(T1_11.java:12)

向下转型不安全的原因我估计是因为父类没有子类的方法，所以以后如果我们要使用这个s去执行一些子类有而父类没有的功能时，就没法执行了，所以编译器就不让我们这样用。

9.只要分配内存了，就相当于给变量赋默认值了，比如下面这段：

package G12;
public class T1_9 {
   
    public static void main(String[] args){
   
        int[] ar=new int[5];
        System.out.println(ar[0]);
    }
}

这段代码不会说ar数组没有初始化，程序运行后输出为0；但是如果我们写成这样：

package G12;
public class T1_9 {
   
    public static void main(String[] args){
   
        int[] ar;
        System.out.println(ar[0]);
    }
}

就会报没有初始化的错：

10.float f=1.3会报错，因为Java里面小数默认是double，而且double不能隐式转成float。

11.start()和run()方法的联系：
1)run()：通过调用Thread类的start方法来启动线程，此时线程是处于就绪状态。并没有运行。然后通过此Thread类调用方法run来完成其运行操作。这里的方法run称为线程体，它包含了要执行的这个线程的内容，run方法运行结束后此线程就终止了，然后CPU再运行其它线程。

二、09年考题

主要盲点：文件读写（字节流还是字符？）、多线程、内部类

1.实现多线程的两个方法：
1）继承扩展Thread类
2）实现Runnable接口（更推荐这个，因为这样既可以多线程，又可以继承其它类）
以上两种方法相同的地方就是主要任务都是重写run方法
2.客户类可以通过完整的类名直接访问静态内部类的静态成员。

3.局部内部类和实例内部类在访问权限上的差别，仅仅是前者还可以访问所在方法中用final修饰的参数和变量，别的都一样，都可以访问外部类的所有成员。

4.匿名类会调用父类的构造方法

5.匿名类之所以叫匿名类，是因为这个类是没有名字的，我们来看一下下面的代码：

class A{}
main(){
	A a=new A();
}

在这段伪代码里，A就是这个类的类名，a是该类一个实例的实例名，然后我们再来看下面的代码：

class A{}
main(){
	A a=new A();
	A aa=new A(){
		void method(){}
	};
	aa.method;
}

我在这段代码里加了一个aa，这时候我们就得到了一个匿名类，然后该匿名类的一个实例名就是aa。
所以，类名和实例名是不一样的，别把两者混淆了。

6.内部类的命名规则：
1）成员内部类：外部类的名字$内部类的名字
2）局部内部类：外部类的名字$数字和内部类的名字
3）匿名类：外部类的名字$数字

7.求String类型长度、数组大小的函数是length()，求容器大小的才是size()

8.String是final类型的类，不能被继承

9.外部类不能用private修饰，但是内部类可以用private修饰。

10.如果不同线程之间的方法体相同，可以使用同一个Runnable对象，也就是实现了共享代码。比如下面这一大段代码：

public class Ticket {
   
    public static void main(String[] args) {
   
        // 创建线程类对象
        TicketSalSystem st = new TicketSalSystem();
        // 启动6次线程
        for (char i = 'A'; i <= 'F'; i++)
        {
   
            /*
             Thread类的构造方法如下：
             public Thread(Runnable run,String name)
             在创建线程的同时，创建线程名称
             */
            new Thread(st, "售票口" + i).start();//【1】
        }
    }
}
class TicketSalSystem implements Runnable
{
   
    // 定义变量---票数/票号
    public int ticket = 100;
    public int count = 0;
    // 重写run()方法
    @Override
    public void run()
    {
   
        // 定义while循环， 循环售票
        while (count<100)//【2】
        {
   
            // 根据题的要求，实现同步，此时定义同步代码块
            synchronized (this)//【3】
            {
   // 传入对象，使用this代替当前类对象
                // 判断是否还有票，如果大于零说明还有票可卖
                if (ticket > 0)
                {
   
                    // 线程休眠0.5秒
                    try
                    {
   
                        Thread.sleep(500);//【4】
                    } catch (InterruptedException e)
                    {
   
                        e.printStackTrace();
                    }
                    count++; // 票号++
                    ticket--;// 循环售票，卖一张少一张
                    // 输出当前的售票窗口和票号
                    System.out.println(Thread.currentThread().getName()
                            + "\t当前票号：" + count);
                }
            }
        }
    }
}

11.Java环境配置的三个变量名：
1）JAVA_HOME：指向Java的JDK安装目录的根目录
2）CLASSPATH：lib目录下两个jar包的安装目录：.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar
3）Path:两个bin文件夹的目录：%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin

12.java文件名和类名的关系（分三种情况）：
1）只有一个类，那文件名必须和类名一致
2）多个类，且没有public类，则文件名与任意一个类名一致即可
3）多个类，且有public类，则文件名必须与public类一致

13.在子类中，每一次调用子类的构造方法时，都必须先调用父类的非静态块和构造方法。父类的静态块如果之前以及加载过了，则不必再次加载

14.InpustStream提供的是字节流(以byte为单位)的读取，Reader类提供的是字符流（以char为单位）的读取

15.创建一个InputStreamReader实例：

new InputStreamReader(new FileInputStream("data.txt"));

16.System.out是一个PrintStream类

17.内部类调用外部类同名变量。 外部类名.this表示外部类对象

三、14年部分考题

1.多线程和String结合：

public class Test extends Thread{
   
    static String Sname="Hello";
    public static void main(String argv[])
    {
   
        Test t=new Test();
        t.start();
    }
    public void run()
    {
   
        for(int i=0;i<4;i++)
        {
   
            Sname=Sname+" "+i;
            System.out.println(Sname);
        }
    }
}

本以为输出是：

Hello 0
Hello 1
Hello 2
Hello 3

但是实际输出是：

Hello 0
Hello 0 1
Hello 0 1 2
Hello 0 1 2 3

原因很简单就是每次循环后字符串String都变了，而且这道题还只有一个线程，所以每次Sname的变化都会影响到下一次。

四、多项式

1.拷贝构造函数：所谓的拷贝构造函数就是构造函数的参数类型是该构造函数所在的类，即参数就是该类的一个对象。

2.private类型的变量在本类中是可以访问的，即使是在另一个同类型的类中，比如下面这段就是可以通过编译并运行的：

public class Test {
   
    public static int i;
    public static void main(String args[]){
   
        System.out.println(i);
        A a=new A();
        a.fun1();
    }
}

class A{
   
    private int l;
    public void fun1(){
   
        A a=new A();
        System.out.println(a.l);
    }
}

五、其它零碎知识

1.C++中的析构函数：析构函数（destructor）与构造函数相反，当对象结束其生命周期，如对象所在的函数已调用完毕时，系统自动执行析构函数。析构函数往往用来做清理善后的工作（例如在建立对象的时候用new开辟了一片内存空间，delete会自动调用析构函数后释放内存）。

2.Java彻底抛弃了struct的概念。

3.对象之间通过消息（方法）相互作用，完成系统的功能

4.join方法：它将引起现行线程等待，直至方法join所调用的线程结束。

public void timeout(){
   
// 暂停该线程，等候其他线程(tt)结束
tt.join();
// 其他线程(tt)结束后，继续进行该线程
……	……
}

六、又来了一套卷：

1.Java中then不是保留字

2.局部变量（在函数内部）必须先初始化，类级别的可以不初始化。但是实例级别（即非静态变量）不能直接在static方法里面用，必须得和某一实例绑定。

int i=9;
switch (i) {
    
default: System.out.println("default"); 
case 0: System.out.println("zero"); 
break; 
case 1: System.out.println("one"); 
case 2: System.out.println("two");
}

以上代码的输出是default，zero.是因为default语句里面没有break语句。（switch的唯一考点真的是有没有break啊！！！！!！！！！！！！！！！！！！！！！！！）

4.>>>无符号右移，空位都用0补齐。但是要注意，Java没有无符号左移

5.构造方法不能被重写

6.ArrayList的访问速度比LinkedList更快（因为前者是通过数组实现的）

7.String类的构造方法的参数如果是数组，那数组类型只能是char,byte.

8.Java的二维数组其实是这样的：先创建一个一维数组，然后该数组的元素再引用另一个一维数组。所以我们可以通过new int[3][]来创建一个长度为3的二维数组。

9.自定义运行时异常时，必须继承自RuntimeException类。（注意，看清楚定语）

10.抽象类除了不能实例化对象外（这是规定），类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。但是接口就不一样了，它没有构造方法，也不能被实例化。（其实容易错在混淆抽象和接口，抽象是abstract，大象，接口是interface，小嘴）

11.Java中的boolean类型是可以参与按位与（&）/按位或（|）运算的.

12.多态有三大形式：接口，重载，重写（覆盖，复写）

13.如果catch/try以及finally块里都有return语句，那么最终的返回值是finally里的返回值。

14.String.Lastindex(String str)就是获取str前面的字符串的长度

15.TCP与UDP的区别：
TCP（transmission control protocol）传输控制协议，是面向连接的通信协议，稳定，但是较UDP效率低。使用TCP协议进行数据传输时，两个进程之间会建立一个连接，数据以流的形式顺序传输。

UDP（user datagram protocol）用户数据协议，是无连接通信协议，速度快但是不稳定。两个进程之间不建立特定的连接，不对数据到达的顺序进行检查。

相同点：传输的都是一个byte stream/字节型的数据流

16.构造方法的作用是用来给属性进行初始化的

17.JVM并不总是会创建默认的无参构造体。比如该类定义了有参的构造方法

18.Thread类位于lang包中，它也是大部分类的默认包

19.网络编程的大部分类都位于java.net包中

20.System中的getProperties()方法用于获取当前操作系统的属性

21.DateFormat中的parse方法返回的是Date，format方法返回的才是String

22.jdk中包含jre,jre中包含jvm

23.同一个构造方法中不能同时含有super（）和this（）,因为它们都要求自己是方法中的第一个语句。

转载：https://blog.csdn.net/yuanren201/article/details/90909015