Java第六章到第九章课后题笔记

本文虽然是课后题答题博客，但不以答题的形式来写这篇博客，而是以知识点的形式来完成这篇博客

第六章

1·this和super的用法有

1.直接引用。
2.形参与成员名字重名，用this区分。子类和弗雷中的成员重名，用super区分。
3.引用构造函数。

2.子类对象实例话的具体过程是子类先调用父类的构造函数，然后再调用自己的构造函数。

3.类的域变量与方法中的局部变量在初始化上的变化在于前者在类实例化的时候就初始化了，后者在方法内显示初始化。

5.接口的作用是：实现多重继承，可扩展性强。

6.抽象类与接口的相同点是，他们都有抽象办法，都不能实例化；不同点在于接口只有静态常量，抽象类可有具体办法

7.引用比较多办法有：equals；==；instanceof。

8.内部类的作用是：使代码变得简洁
在以下情况下可使用内部类：

1.只用到一个类实例
2.类在定义后马上用到
3.类十分小

9.类的初始化过程是先调用基类的构造函数后初始化自身成员后在调用自身构造函数

10.数据隐藏是在子类对父类的继承中，如果子类的成员变量和父类的成员变量同名，此时称为子类隐藏（override）了父类的成员变量。
子类重写父类的方法，要求方法名和参数类型完全一样(参数不能是子类)，返回值和异常比父类小或者相同(即为父类的子类)，访问修饰符比父类大或者相同。
隐藏：父类和子类拥有相同名字的属性或者方法（ 方法隐藏只有一种形式，就是父类和子类存在相同的静态方法）时，父类的同名的属性或者方法形式上不见了，实际是还是存在的。

11.平行类之间不能相互引用，子类不能引用父类

第七章

1.不对。异常分为runtime异常与非runtime异常，runtime异常，用户可以选择不处理，也可以选择处理，如果出现了这种异常，那么一定是写程序的人的问题。

2.创建自定义异常类

public class MyException extends Exception
{
	MyException(String msg){
		super(msg);   //调用Exception的构造方法
	}
	static void throwOne() throws MyException
	{
		
		if (true)
		{throw new MyException("My intentional exception");}		
	}
	public static void main(String args[])
	{
		try
		{throwOne();}
		catch(MyException e)
	    {e.printStackTrace();}
	}
}

输出为：

MyException: My intentional exception
	at MyException.throwOne(MyException.java:11)
	at MyException.main(MyException.java:16)

3.当应用程序试图在需要对象的地方使用 null 时，抛出该异常。这种情况包括：
调用 null 对象的实例方法。
访问或修改 null 对象的字段。
将 null 作为一个数组，获得其长度。
将 null 作为一个数组，访问或修改其时间片。
将 null 作为 Throwable 值抛出。
应用程序应该抛出该类的实例，指示其他对 null 对象的非法使用。

public class Test
{
       public static void aMethod() throws Exception{ 
             try{ 
                   throw new Exception();
                  }
/*黑体
              catch(Exception e){
                    System.out.println("exception000");
                   }

*/
/*斜体
               finally{
                   System.out.println("exception111");
               }
*/
        }
        public void main(String[] args){
                try{
                        aMethod();
                 }
                  catch(Exception e){
                         System.out.println("exception");
                  }
                  System.out.println("finished");     
         } 
}

输出结果分别为：

//无删除
exception000
exception111
finished
//删除黑体
exception111
exception
finished
//删除斜体
exception000
finished

tip:exception只能被catch一次，finally会在catch后进行。

public class Test{
        public static String output ='';
        public static void foo(int i){
               try{
                       if(i==1) {throw new Exception();}
                       output += "1";
                }
                catch(Exception e){
                        output += "2";
                        return;
                 }
                 finally{output += "3";}
                 output += "4";
            }
           public static void main(String args[]){
                   foo(0);
                   foo(1);
                   System.out.println(Test.output);
             }
}

输出结果为：

13423

tip:因为一旦出现catch判断的异常，马上会运行catch中的内容，运行完后再运行finally的内容，其他代码不会运行。

8.任何办法内若出现抛出异常的操作，则必须在方法名后加上throws XXXException，例如：

public void method()throws TimedOutException
          {
        	  success= connect();
        	  if(success == -1)
        	  {
        		  throw new TimedOutException();
        	  }
          }

编程题

6.编写一个程序方法，对空指针异常、除数为零异常给出出错的中文提示。当有新异常发生时，可扩展该方法中的代码进行统一处理。

public class MyException{
	public static void main(String[] args) {
        try {
        	String s = null;
            System.out.println(1/0);//除零异常
            System.out.println(s.toLowerCase());
        }catch (NullPointerException e) {
            System.out.println("空指针异常");
        }catch (ArithmeticException e) {
            System.out.println("除数为零异常");
        }catch (Exception e) {
            System.out.println("其他异常");
            e.printStackTrace();
        }
    }
}

7.从屏幕输入10个数，在输入错误的情况下，给出相应的提示，并继续输人。在输入完成的情况下，找到最大最小数。

import java.util.Scanner;

public class MyException{
	public static void main(String[] args) {
        int index = 0;
        int[] array = new int[10];
        while (index!=array.length) {
              
              Scanner sc = new Scanner(System.in);
              System.out.print("输入" + (index + 1) + ":");
              try {
                   array[index] = sc.nextInt();
                   index++;
               } 
               catch (Exception e) {System.out.println("输入错误，重新输入!");}
         }
         int max = array[0];
         int min = array[0];
         for (int i = 1; i < array.length; i++) {
               if (array[i] > max) {max = array[i];}
               if (array[i] < min) {min = array[i];}
          }
         System.out.println("max = " + max);
         System.out.println("min = " + min);
        
   }

}

第八章

3.String类的特点是：

1.String对象是不可变的，在String类中每一个看起来会修改String对象内容的方法，实质都是创建了一个全新的String对象。
2.String类作为参数时，尽管是传引用，但通过形参引用并未改变实参指向的字符串内容

4.String类在使用equals方法时进行值比较，使用==时进行引用比较。

5.String与StringBuffer的区别在于：StringBuffer对象是可变的，修改StringBuffer对象内容会直接修改到堆上去。
他们之间相互转化的办法是：
第一种：StringBuffer a=new StringBuffer（String b）；
String b=new String（a）；
第二种：String a=b.toString（）；

第九章

1.线程与进程的区别：同类的多个线程共享一块内存空间和一组系统
资源，而线程本身的数据通常只有微处理器的寄存器数据，以及一个供程序
执行时使用的堆栈。所以系统在产生一个线程，或者在各个线程之间切换时，
负担要比进程小的多 。

2.应用程序必须运行完所有前台线程才能退出，应用程序是否退出与后台线程无关，应用程序退出后所有后台线程自动关闭。

3.创建线程有两种办法：
第一种是直接继承thread类，这种操作虽然简单，但因为java单继承的机制，限制较大。
第二种是使用runnable接口，然后通过thread的构造办法创建线程，这种办法虽然较为麻烦一些，但可以可扩展性强。

4.线程的生命周期有：

1、创建状态：线程对象已经创建，还没有在其上调用start()方法。
2、可运行状态：当线程有资格运行，但调度程序还没有把它选定为运行线程时线程所处的状
态。当start()方法调用时，线程首先进入可运行状态。在线程运行之后或者从阻塞、等待或
睡眠状态回来后，也返回到可运行状态。
3、运行状态：线程调度程序从可运行池中选择一个线程作为当前线程时线程所处的状态。这
也是线程进入运行状态的唯一一种方式。
4、阻塞状态：这是线程有资格运行时它所处的状态。如执行了join/sleep/wait方法，会
让出CPU，只有当引起阻塞的原因消除时，线程才能转入就绪状态。
5、死亡态：当线程的run()方法完成时就认为它死去。或者抛出一个未捕获到的
Exception或Error。

5.线程的安全问题是：多线程同时访问共享资源（变量）。
解决方法是：使用监视器，用Synchronized关键字修饰相关代码，使得同一时间内只能最多有一个线程能运行。

6.线程同步通信是希望实现两个或多个线程之间的某种制约关系。实现方法为：利用volatile boolean来判断可否运行线程，当满足一定条件时，用notifyall（）与wait（）方法来激活所有线程或自身进入阻塞状态。

7.如果多个线程都处于等待状态，彼此需要对方所占用的监视器所有权，
就构成死锁（deadlock），Java即不能发现死锁也不能避免死锁。

方法一：{
synchronized(A) {
     ….
    synchronized(B) {
        ….
    }
}
}

方法二：{
synchronized(B) {
     ….
    synchronized(A) {
        ….
    }
}
}