武汉北大青鸟java培训07-学习java笔记

　　武汉北大青鸟java培训07-学习java笔记。

        一、封装类

　　JAVA 为每一个简单数据类型提供了一个封装类，使每个简单数据类型可以被Object 来装载。

　　除了int 和char，其余类型字母大写即成封装类

　　int Integer

　　char Character

　　int Integer String之间的类型转换(常用的)

　　int a =12;

　　int 到 Integer Integer aa = new Integer(a);

　　Integer 到 int int i = aa.intValue();

　　Int 到 String String str = String.valueOf(i);

　　String 到 int int ii = Integer.parseInt(str);

　　Integer 到 String String str = aa.toString()

　　String 到 Integer Integer bb = Integer.valueOf(str)

　　二、 内部类(非重点)

　　1.定义：定义在其他类中的类，叫内部类。内部类是一种编译时的语法。编译后生成的两个类时独立的两个类。内部类配合接口使用，来强制做到弱耦合(局部内部类，或私有成员内部类)。

　　2.内部类存在的意义在于可以自由的访问外部类的任何成员(包括私有成员)，所有使用内部类的地方都可以不用内部类，使用内部类可以使程序更加的简洁(以牺牲程序的可读性为代价)，便于命名规范和划分层次结构。

　　3.内部类作为外部类的一个成员，并且依附于外部类而存在的。

　　4.内部类可为静态，可用PROTECTED 和PRIVATE 修饰。(而外部类不可以：外部类只能使用PUBLIC和DEFAULT)。

　　5.内部类的分类：成员内部类、局部内部类、静态内部类、匿名内部类。

　　① 成员内部类：作为外部类的一个成员存在，与外部类的属性、方法并列。

　　内部类和外部类的实例变量可以共存。

　　在内部类中访问实例变量：this.属性

　　在内部类访问外部类的实例变量：外部类名.this.属性。

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

　　成员内部类不可以有静态属性，这是因为静态属性是在加载类的时候创建，这个时候内部类还没有被创建。

　　如果在外部类的外部访问内部类，使用out.inner.

　　建立内部类对象时应注意：

　　在外部类的内部可以直接使用inner s=new inner();(因为外部类知道inner 是哪个类，所以可以生成对象。)

　　而在外部类的外部，要生成(new)一个内部类对象，需要先建立一个外部类对象(外部类可用)，然后在生成一个内部类对象。

　　Outer.Inner in=Outer.new.Inner()。

　　相当于：Outer out = new Outer();

　　Outer.Inner in = out.new Inner();

　　错误的定义方式：

　　Outer.Inner in=new Outer.Inner()。

　　② 局部内部类：在方法中定义的内部类称为局部内部类。

　　与局部变量类似，在局部内部类前不加修饰符public 和private，其范围为定义它的代码块。

　　注意：局部内部类不可以访问外部类实例变量，还可以访问外部类的局部变量(但此时要求外部类的局部变量必须为final)

　　在类外不可直接生成局部内部类(保证局部内部类对外是不可见的)。

　　要想使用局部内部类时需要生成对象，对象调用方法，在方法中才能调用其局部内部类。

　　③ 静态内部类：(注意：前三种内部类与变量类似，所以可以对照参考变量)

　　静态内部类定义在类中，任何方法外，用static 定义。

　　静态内部类只能访问外部类的静态成员。

　　生成(new)一个静态内部类不需要外部类成员：这是静态内部类和成员内部类的区别。静态内部类的对象可以直接生成：

　　Outer.Inner in=new Outer.Inner();

　　对比成员内部类：Outer.Inner in = Outer.new Inner();

　　而不需要通过生成外部类对象来生成。这样实际上使静态内部类成为了一个类。

　　静态内部类不可用private 来进行定义。例子：

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

　　/*********************************************************/

　　public class TestRobot{

　　public static void main(String[] args){

　　Robot r = new Robot();

　　r.run();

　　r.getHeart().run();

　　}

　　}

　　abstract class People{

　　abstract void run();

　　}

　　interface Machine{

　　void run();

　　}

　　class Robot extends People{

　　class Heart implements Machine{

　　public void run(){

　　System.out.println("发动机跑");

　　}

　　}

　　public void run(){

　　System.out.println("机器人跑");

　　}

　　public Machine getHeart(){

　　return new Heart();

　　}

　　}

　　/*************************************************************************/

　　此时run()不可直接实现。

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

　　④ 匿名内部类：

　　【1】 匿名内部类是一种特殊的局部内部类，它是通过匿名类实现接口。

　　【2】 不同的是他是用一种隐含的方式实现一个接口或继承一个类，而且他只需要一个对象

　　【3】 在继承这个类是，根本就没有打算添加任何方法。

　　【4】 匿名内部类大部分情况都是为了实现接口的回调。

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

　　因其为局部内部类，那么局部内部类的所有限制都对其生效。

　　匿名内部类是一种无构造方法类。

　　注：这是因为构造器的名字必须合类名相同，而匿名内部类没有类名。

　　匿名内部类在编译的时候由系统自动起名Out$1.class。

　　因匿名内部类无构造方法，所以其使用范围非常的有限。

　　接口+内部类才能真正实现多继承。

　　一个关于匿名内部类的例子：

　　/******************************************************/

　　public class test{

　　public static void main(String[] args){

　　B.print(new A(){

　　public void getConnection(){

　　System.out.println("Connection....");

　　}

　　});

　　}

　　}

　　interface A{

　　void getConnection();

　　}

　　class B{

　　public static void print(A a){

　　a.getConnection();

　　}

　　}

　　/******************************************************/

　　三、 异常 Exception

　　1. 概念： JAVA 会将所有的错误封装成为一个对象，其 根本父类为Throwable。异常处理可以提高我们系统的容错性。

　　Throwable 有两个子类：Error 和Exception。

　　Error:一般是底层的不可恢复的错误。

　　Object

　　↑

　　Throwable

　　↑

　　|ˉˉˉˉˉˉˉˉ|

　　Error Exception

　　↑

　　|ˉˉˉˉˉˉˉ|

　　RuntimeException 非Runtime exception

　　2. Exception分类：Runtime exception(未检查异常)和

　　非Runtime exception(已检查异常)。

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

　　几个常见的未检查异常：

　　1) java.lang.ArithmeticException

　　如：分母为0;

　　2) java.lang.NullPointerException

　　如：空指针操作;

　　3) java.lang.ArrayIndexoutofBoundsExceptio

　　如：数组越界;

　　4) java.lang. ClassCastException

　　如：类型转换异常;

　　已检查异常是不可避免的，对于已检查异常必须处理。

　　3、异常对象的传递。

　　当一个方法中出现了异常而又没做任何处理，那么这个方法会返回该异常对象。依次向上层调用者传递，直到传到JVM，虚拟机终止运行。

　　4、如何来处理异常(这里主要是针对已检查异常)

　　【1】 throws 消处理异常的方式。

　　方法名(参数表)throws 后面接要往上层抛的异常。

　　表示该方法对指定的异常不作任何处理，直接抛往上一层。

　　【2】 积处理方式try、catch

　　try {可能出现错误的代码块} catch(exception e){进行处理的代码} ;

　　一个异常捕获只会匹配一次try,catch.

　　一个异常一旦被捕获就不存在了。

　　Catch中要求必须先捕获子类异常再捕获父类异常。

　　【3】 finally (紧接在catch代码块后面)

　　finally后的代码块是无论如何都会被执行的(除非虚拟机退出)，所以在finally后的代码快里我们一般写的是释放资源的代码。

　　Public static int fn(int b){

　　Try{

　　Return b/2;

　　}catch(Exception e){

　　return 0;

　　}finally{

　　return b;

　　}

　　}

　　返回的结果是一定是b;

　　5、 自定义异常(与一般异常的用法没有区别)

　　class MyException extends Exception{

　　public MyException(String message){

　　super(message);

　　}

　　public MyException(){}

　　}

　　6、如何控制try的范围：根据操作的连动性和相关性，如果前面的程序代码块抛出的错误影响了后面程序代码的运行，那么这个我们就说这两个程序代码存在关联，应该放在同一个try中。

　　7、不允许子类比父类抛出更多的异常。

　　8、断言：只能用于代码调试时用。(一般没什么用)

　　一个关于断言的列子：

　　/******************************************************/

　　public class TestAssertion {

　　public static void main(String[] args){

　　int i = Integer.parseInt(args[0]);

　　assert i==1:"ABCDEFG";

　　/*

　　断言语句(表示断言该boolean语句返回值一定为真，如果断言结果为false就会报Error错误)

　　":"后面跟出现断言错误时要打印的断言信息。

　　*/

　　System.out.println(i);

　　}

　　}

　　//java -source 1.4 TestAssertion.java

　　//表示用1.4的新特性来编译该程序。

　　//java -ea TestAssertion 0

　　//表示运行时要用到断言工具

　　/********************************************************/

       武汉北大青鸟光谷校区java培训学习课程：17740513250