CoreJava学习笔记7

很重要的一章哦

Java封装类

Java为每一个简单数据类型提供了一个封装类，每个简单数据类型可以封装成对象类型。

除int（Integer）和char（Character），其余类型首字母大写即成封装类类型名。double (Double), float(Float),long(Long), short(Short),byte(Byte),boolean(Boolean)

转换字符的方式：

int I=10;
String s=I+” ”;
String s1=String.valueOf(i);
 
Int I=10;
Interger I_class=new integer(I);

封装类.字符串.基本类型

Interger--------------------(Double(x.toString))--------------->Double
String ---------------------(Integer.valueOf() )---------------->Integer
Integer---------------------(x.toString() )-------------------->String
int-------------------------(100+””)------------------------->String
String----------------------(Integer.parseInt() )--------------->int
Integer---------------------(Integer.intValue() )--------------->int

学会查看java的帮助文档。先要关注使用方法的返回值类型，也就是要获得内容的类型，然后看方法名，JDK中的方法名基本上是见名知义，参数表，看需要什么才可以获得的需要的内容，也要看自己能够提供什么作为参数。

注意：“==”在任何时候都是比较地址，这种比较永远不会被覆盖。

程序员自己编写的类和JDK类是一种合作关系。（因为多态的存在，可能存在我们调用JDK类的情况，也可能存在JDK自动调用我们的类的情况。）

注意：类型转换中Double\Interger\String之间的转换最多。


（注：所有使用内部类的地方都可以不用内部类，但使用内部类可以使程序更加的
。


内部类

内部类是指在一个外部类的内部再定义一个类。
*内部类可为静态，可用protected和private修饰。（而外部类不可以：顶级类只能使用public和default）。
*JAVA文件中没有publie class 可以类名和文件不同名

内部类的分类

成员内部类、   
局部内部类、
静态内部类、
匿名内部类（图形是要用到，必须掌握）。

成员内部类

四个访问权限修饰符都可以修饰成员内部类。

内部类和外部类在编译时是不同的两个类，内部类对外部类没有任何依赖。
内部类是一种编译时语法，在编译时生成各自的字节码文件，内部类和外部类没有关系。
内部类中可以访问外部类的私有成员。
内部类是作为外部类的一个成员存在，与外部类的属性、方法并列。
内部类和外部类的实例变量可以共存。
在内部类中访问实例变量：this.属性
在内部类访问外部类的实例变量：外部类名.this.属性。
在外部类的外部访问咋内部类，使用out.inner.

成员内部类的特点：

1．内部类作为外部类的成员，可以访问外部类的私有成员或属性。（即使将外部类声明为private，但是对于处于其内部的内部类还是可见的。）

2．用内部类定义在外部类中的不可访问的属性。这样就在外部类中实现了比外部类的private还要小的访问权限。

注意：内部类是一个编译时的概念，一旦编译成功，就会成为完全不同的两类。

对于一个名为outer的外部类和其内部定义的名为inner的内部类。编译完成后出现outer.class和outer$inner.class两类。

3．成员内部类不能含有静态成员。

建立内部类对象时应注意：
在外部类的内部可以直接使用inner s=new inner();（因为外部类知道inner是哪个类，所以可以生成对象。）
而在外部类的外部，要生成（new）一个内部类对象，需要首先建立一个外部类对象（外部类可用），然后在生成一个内部类对象。内部类的类名是外部类类名.内部类类名。

例：

public class Test{
     public static void main(String[] args){
         Outer o=new Outer();
Outer.Inner in=o.new Inner();
Outer.Inner in=(new Outer).new Inner();
}
}
 
class Outer{
     private int a
     class Inner{
         private int b;
         public Inner(){
              this.b=Outer.this.a
         }
     }
     ……
}

静态内部类

（注意：前三种内部类与变量类似，所以可以对照参考变量）
静态内部类定义在类中，任何方法外，用static class定义。
静态内部类只能访问外部类的静态成员。

静态内部类和成员内部类的区别
创建（new）一个静态内部类不需要外部类成员：这是静态内部类和成员内部类的区别。
静态内部类的对象可以直接生成：
Outer.Inner in=new Outer.Inner()；
而不需要通过生成外部类对象来生成。静态内部类成为了一个和外部类平等的类。静态内部类不可定义为private。
例：

public class Test{
     public static void main(String[] args){
Outer.Inner in=new Outer.Inner()；
}
}
 
class Outer{
     private static int a
     static class Inner{
         private int b;
         public Inner(){
              this.b=Outer.this.a
         }
     }
     ……
}

注意：当类与接口（或者是接口与接口）发生方法命名冲突的时候，此时必须使用内部类来实现。用接口不能完全地实现多继承，用接口配合内部类才能实现真正的多继承。

例子：

对于两个类，拥有相同的方法：

class People
{
  run();
}
interface Machine{
   run();
}
此时有一个robot类：
class Robot extends People implement Machine.
此时run()不可直接实现。
 
interface Machine
{
     void run();
}
class Person
{
     void run(){System.out.println("run");}
}
class Robot extends Person
{
     private class MachineHeart implements Machine
     {
         public void run(){System.out.println("heart run");}
     }
     public void run(){System.out.println("Robot run");}
     Machine getMachine(){return new MachineHeart();}
}
class Test
{
     public static void main(String[] args)
     {
         Robot robot=new Robot();
         Machine m=robot.getMachine();
         m.run();
         robot.run();
     }
}
 

局部内部类

局部内部类是定义在方法中的内部类。
局部内部类不能够加权限修饰符，其范围为定义它的代码块。

注意：局部内部类不仅可以访问外部类私有实例变量，但可以访问外部类的局部常量（也就是局部变量必须为final的）

局部内部类的特点：不能直接访问局部内部类（保证局部内部类对外是不可见的）,只有在方法中才能访问其局部内部类。

局部内部类的作用

通过内部类和接口达到一个强制的弱耦合，用局部内部类来实现接口，并在方法中返回接口类型，使局部内部类不可见，屏蔽实现类的可见性。

局部内部类写法

public class TestLocalInnerClass{
     public static void main(String[] args){
         Outer o=new Outer();
         final int a=9;
         o.print(a);
     }
}
 
class Outer{
     private int index=100;
     public void print(final int a){
         final int b=10;
         System.out.println(a);
         class Inner{
              public void print(){
                   System.out.println(index);
                   System.out.println(a);
                   System.out.println(b);
               }                 
         }
         Inner i=new Inner();
         i.print();
     }
}

匿名内部类

匿名内部类是一种特殊的局部内部类，可通过匿名类隐式的实现接口。

匿名内部类的特点：
1，一个类用于继承其他类或是实现接口，并不需要增加额外的方法，只是对继承方法的事先或是覆盖。
2，只是为了获得一个对象实例，不许要知道其实际类型。
3，类名没有意义，也就是不需要使用到。

注：一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类，没有类名，根据多态，我们使用其父类名。

匿名内部类的特点
1) 因其为局部内部类，那么局部内部类的所有限制都对其生效。
2) 匿名内部类是唯一一种无构造方法类。
3)大部分匿名内部类是用于接口回调用的。
4)匿名内部类在编译的时候由系统自动起名Out$1.class。
5)一个对象编译时的类型是接口，那么其运行的类型为实现这个接口的类。
6)因匿名内部类无构造方法，所以其使用范围非常的有限。

匿名内部类和局部内部类的区别
需要返回多个对象时，使用局部内部类，局部内部类的应用相对较多。匿名内部类中不写构造方法。

匿名内部类的写法：

interface M{
     void a();    
}
class N{
     public M b(){
         return new M{
              void a(){
                   System.out.println(“a”)
              }
         };
        }
}
使用匿名内部类：
public class Test{
public static void main(String[] args){
N n=new N();
M m=n.b();
m.a();
}
}

Exception（例外/异常）

对于程序可能出现的错误应该做出预案。
异常是程序中所有出乎意料的结果。（关系到系统的健壮性）

JAVA会将所有的异常封装成为一个对象，其根本父类为Throwable。

异常的分类

Throwable有两个子类：Error和Exception。

Error对象表示程序错误，是底层的、低级的、不可恢复的严重错误。此时程序一定会退出，已经失去了运行所必须的物理环境。对于Error错误无法进行处理。因为我们是通过程序来应对错误，可是程序已经退出了，就无法处理了。

我们可处理的只是Exception类的对象表示的程序异常（例外/异常）。

Exception有两个子类：Runtime exception：（未检查异常）可以在编程时避免，可处理可不处理
                     非Runtime exception：（已检查异常）必须进行处理。

注意：无论是未检查异常还是已检查异常在编译的时候都不会被发现，在编译的过程中检查的是程序的语法错误，而异常是一个运行时程序出错的概念。

未检查异常是因程序员没有进行必要的检查，因疏忽和错误而引起的异常。属于虚拟机内部的异常（比如空指针）。

应对未检查异常就是养成良好的检查习惯。
已检查异常是不可避免的，对于已检查异常必须事先定义好处理方法。
已检查异常是跨越出了虚拟机的范围外的异常。（比如“未找到文件”）

异常的传递

如何处理已检查异常（对于所有的已检查异常都要进行处理）：
首先了解异常形成的机制：
一个方法中有一条语句出现了异常，会throw（抛出）一个例外对象（throw 异常对象），其后的语句不会执行并将异常返回给上一级方法，上一级方法接受到了例外对象后，可能对这个异常进行处理，也可能将这个异常继续向上传递。

注意：当一个方法中出现了异常，没有进行异常处理，方法就会把异常对象作为返回值返回。如果有异常进入虚拟机，那么虚拟机就会立刻中止程序的执行。

异常的处理方式

非RuntimeException 已检查异常必须处理，不处理编译不通过。

已检查异常处理方式：throws和try..catch(...){}方法。

注意：抛异常的方法可能是JDK定义的，也可能是程序员写的程序，无论谁写的，抛出一定用throw。

方法的定义中声明方法可能抛出的异常，用（throws 异常类名，异常类名） ，声明这个方法不处理异常，把异常交给上一级方法处理。可以抛出的是实际产生异常或其父类的异常对象。

例：public void print() throws Exception{}

对于方法a，定义了throws Exception。它调用的方法b返回异常对象时，方法a并不处理，将这个异常对象向上一级返回，所有的方法均不进行处理，异常返回到主方法，程序会中止。（要避免所有的方法都向上级抛异常，因为这样出现一个很小的异常就会令程序中止）。

throws（抛）异常时，可以使用多态，一个方法声明抛出异常时，调用这个方法的方法就要处理该异常（已检查异常），要么抛出一个兼容类型的异常（调用的方法抛出异常的父类或者是相同类型）

例：

public class Test{
     public static void main(String[] args)throws Exception{
              Test t=new Test()
              t.a()
     }
     public void a()throws IOException,EOFException{
              b();
              ……
}
public void b()throws EOFException{
     ……
}
}

在方法的程序中有一行throw new Exception()，抛出异常，其后的程序不再执行。异常对象抛出后，后面的程序没有执行机会，JAVA认为异常出现后的程序没有存在的必要。

try..catch捕获异常

对于try……catch格式：
try {
可能出现错误的代码块
}catch(Exception e){
进行处理的代码
}
                          

用这种方法，代码正确，程序不经过catch语句直接向下运行；
代码不正确，则将抛出的异常对象和e的类型进行匹配，匹配成功，运行相应异常处理代码即catch块中代码。（用Exception来声明e的话，Exception为所有异常对象的父类，所有肯定匹配成功）。处理完代码后这个例外就完全处理完毕，程序会接着捕获异常的catch块的地方向下执行，最后程序正常退出。

try块中的代码如果没有出现异常，就会跳过catch，正常执行。
try块中抛出了异常，即跳出try块去匹配catch块，try块中抛出异常之后的语句不会执行，在try块中不能写return语句。

一个try块可以跟多个catch块，用于处理不同情况。一个try块中抛出异常后只匹配一个和处理抛出类型异常兼容的catch块。
我们可以写多个catch块，不能将声明处理try块中抛出实际异常类型的父类型异常的catch块，写在声明处理try块中抛出的实际类型异常的catch块之前。
try块中抛出的异常，先匹配处理其实际异常类型的父类型的catch块，处理抛出实际类型异常的catch块成了永远不会被执行的代码，java中是不允许写这样的代码，编译不通过。

例:
EOFException是IOException的子类，以下写法是错误的，编译不通过
try{
     ……
}catch(IOException e){
     ……
}catch(EOFException ex){
     ……
}

finally关键字

finally{……}在finally语句块中的代码无论如何都会运行

try，catch后还可以再跟一个finally块。finally块中的代码语句无论如何（无论有没有异常）都会执行（finally块多写一些释放资源，关闭连接的代码）。finally块中的代码在和try块中的代码的冲突时，finally块中的代码一定会执行且会忽略try块中的代码。但是System.exit(0);(虚拟机退出语句)后则不执行fianlly中的代码。

try{..}catch(..){..}
try{..}catch(..){..}finally{..}
try{..}finally{..}
以上三种写法都可以。

程序中抛出异常就要处理，无论是使用throws，还是用捕获是用try，catch，不对异常进行处理，编译不通过。

如何知道在编写的程序中会出现例外呢
1．调用方法，查看API中查看方法中是否有已检查错误。
2．在编译的过程中看提示信息，然后加上相应的处理。

Throwable有一个message属性。在使用catch的时候可以调用：

try{……}Catch(IOException e){System.out.println(e.message());}//异常的信息的显示
try{……}Catch(IOException e){e. printStackTrace();}//异常堆栈信息的显示

printStackTrace()方法是打印异常堆栈信息，是常用的异常处理的访法，它是异常的方法。

以上两条语句都可打印出错的信息。告诉我们出错类型及代码的运行过程，在调试的中非常有用。

例：

public class TestHundredException{
     public static void main(String[] args){
         MyClass mc=new MyClass();
         try{//在这个try语句块中抛出的异常会得到处理
              System.out.println(mc.add(10,80));
         }
         catch(HundredException e){
//捕获try块中抛出的异常
              e.printStackTrace();
         }
         try{
              System.out.println(mc.add(30,70));
         }
         catch(HundredException e){
              e.printStackTrace();
         }finally{
              System.exit(0);
         }
     }
}
class HundredException extends Exception{//自定义异常
     public HundredException(String message){
         super(message);
     }
}
 
class MyClass{
     public int add(int a,int b) throws HundredException{
         int c=a+b;
         if (c==100) {
throw new HundredException("a+b can\'t be 100");
else{ 
return c;
         }
     }
}

自定义异常

自定义异常要是Exception的子类，以下是一个例子：
自己定义异常类必须是Excepiton或者RuntimeException的子类。

public class TestMyException{
     public static void main(String[] args){
         int n=Integer.parseInt(args[0]);
         A a=new A();
         try{
              a.calculate(n);
         }
         catch(Exception e){
              e.printStackTrace();
         }
         System.out.println("OK");
     }
}
class A{
     public void calculate(int n) throws ZhiShuException{
         for(int i=2;i<n;i++){
              if (n % i == 0) return;
         }
         throw new ZhiShuException(n+" is a Prime Number");
     }
}
 
class ZhiShuException extends Exception{//自定义的异常，是Exception的子类
     public ZhiShuException(String message){
//注意在构造父类对象时需要String类型的message作为参数
         super(message);
     }
}

开发中的两个道理：
①     如何控制try块的范围：根据操作的连动性和相关性，前面的程序代码块抛出的异常影响了后面程序代码的运行，这两个段程序代码就存在关联，应该放在同一个try块中。

②     对已经查出来的例外，有throw(消极)和try {…}catch(…){…}（积极）两种处理方法。对于throws把异常抛到try catch能够恰当地处理异常的位置（即放在具备对这个异常进行处理的能力的位置）。没有处理异常的能力就将异常继续上抛。

throw是一个语句，用来做抛出例外的功能。
throws是表示本方法中会异常抛出，本方法不做处理，将异常对象向上抛出。
throws写的是异常类型，throw后写的是要抛出的异常对象。

注意：方法的覆盖中，如果子类的方法抛出的例外是父类方法抛出的例外的父类型，那么编译就会出错：子类无法覆盖父类。

结论：子类方法不可比父类方法抛出更多的例外。子类抛出的例外或者与父类抛出的例外一致，或者是父类抛出例外的子类型。或者子类型不抛出例外。如果父类型无throws时，子类型也不允许出现throws。此时只能使用try catch。

断言是一种调试工具（assert）

其后跟的是布尔类型的表达式，如果表达式结果为真不影响程序运行。如果为假系统出现低级错误，在屏幕上出现assert信息。
Assert只是用于调试。在产品编译完成后上线assert代码就被删除了。