黑马程序员——java面向对象和异常

                             ---------- android培训、java培训、java学习型技术博客、期待与您交流！ ----------
 

面向对象是相对面向过程而言的。老毕通过了“把大象装进冰箱”这个例子给我们讲解了两者的区别。面向过程是强调动作，面向对象是强调了具备功能的对象。

Java有三个特性：封装、继承、多态。这三个特性很重要，掌握了它，面向对象基本上就掌握  了，剩下的就是经验而已。

    1、封装

封装：是指是指隐藏对象的属性和实现细节,对外仅提供公共访问方式。

好处：将变化隔离，便于使用。提供复用性。提高安全性。

封装原则:将不需要对外提供的内容隐藏起来,把属性都隐藏,仅对处提供公共方法对其访问.

封装属性用private来修饰.封装后要提供外部对其访问的接口.之所以提供访问方式.就因为可以在访问方式中加入逻辑判断等语句,对访问的数据进行操作,提高代码的健壮性.

class Person {
    private int age;//私有化

 //对外提供set方法和get方法
   public void setAge(int age){
           if (age>120 && age<1){

                   this.age=1;

           }else{

                  this.age=age;

          }

 }
  public int getAge(){
       return this.age;
  }
}

 

2、继承

把对象中的共性描述提取出来单独封装成一个类，然后让对象所属的类extends这个封装的类。

继承提高了代码的复用性，让类与类之间产生关系，有了这个关系才有了对象的多态性。

必须是类与类之间有所属关系才可以继承，不能单独的为了实现某功能而继承.所属关系is a。

Java是单继承多实现,支持多层继承.

当之类继承父类,沿袭了父类的功能到子类中,但子类的该功能和父类的不一致时没有必要定义新功能,而是使用覆盖(Override),保留父类的功能定义,并重写功能内容.

Override时要保证子类的权限不能比父类的权限小.

在对子类对象进行初始化是地,父类的构造函数也会运行,因为子类的构造函数默认第一行都有一条隐式的语句super();

super():会访问父类中空参数的构造函数.而且中所有的构造函数默认第一行都是super());

为什么子类一定要访问父类中的构造函数.?

因为父类中的数据子类可以直接获取,所以子类建立对象时,需要先查看父类是如何对这些数据进行初始化的.

如果要访问父类中指定的构造函数,可以通过手动定义super语句的方式来指定.

super()语句一定子类构造函数的第一行。使用了super，就不能使用this。因为他们都要在第一行，无法两个一起用。

子类的实例化过程。

子类中所有的构造函数默认都会访问父类中空参数的构造函数.当父类中没有空参的构造函数时,子类必须通过super语句形式来指定要访问的构造函数.子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数.子类中至少会有一个构造函数会访问父类中的构造函数.

3、多态

多态，可以理解为事物存在的多种体现形态。

    

Animal c=new cat;

（1）多态的体现

父类的引用指向自己的子类对象.

父类的引用也可以接收自己的子类对象.

（2）多态的前提

必须是类与类之间有关系,要么继承,要么实现.

通常还有一个前提,存在覆盖.

（3）多态的好处

多态的出现大大的提高程序的扩展性.

（4）多态的应用

（5）多态的弊端

提高了扩展性,但是只能使用父类的引用访问父类中的成员.

（6）多态的出现代码中的特点

在多态中成员函数的特点:

在编译时期:参阅引用型变量所属的类中是否有调用的方法,如果有,编译通过,如果没有,编译失败.

在运行时期:参阅对象所属的类中是否有调用方法.

简单总结就是编译时看左边,运行时看右边.

在多态中,成员变量的特点:(非静态的)

无论编译和运行,都参考左边(引用型变量所属的类)

多态类型提升,向上转型

强制将父类的引用转成子类类型.向下转型

要熟悉对象的初始化过程，这一点很重要。

 

/*

父类和子类都定义有相同的【静态变量】【静态方法】【成员变量】【成员方法】，

当 Father son = new Son();时，son调用变量和方法，到底是调用哪个呢？

*/

class Father

{

static int n = 10;

int c = 100;

public static void run()

{

System.out.println("staic father is funning");

}

public void go()

{

System.out.println("father is going");

}

}

class Sun extends Father

{

static int n = 20;

int c = 200;

public static void run()

{

System.out.println("staic sun is funning");

}

public void go()

{

System.out.println("sun is funning");

}

}

public class FS

{

public static void main(String args[])

{

Father sun = new Sun();

sun.run();//静态调用父类的

sun.go();//调用子类的

//不管是静态变量还是成员变量，都是调用父类的

//System.out.println("n="+Father.n);两者结果一样

System.out.println("n="+sun.n);

System.out.println("c="+sun.c);

//如果想调用Sun中的n，则使用

System.out.println("n="+Sun.n);

}

}

 

 

 

4、this关键字

this关键字用于区分局部变量和成员变量同名的情况。前面加上this就代表本类的对象。它代表它所在函数所属对象的引用，即那个对象使用函数或成员变量，this就表示这个对象。和this相对的是super它对应父类的。

this的应用：当定义中的功能时,该函数内部要用到调用该函数的对象时。用this来表示这个对象，只要是本类功能内部使用了本类对象，都可以用this来表示。

this语句构造函数间调用.

public class ConstructorTransfer {

    Public staticvoidmain(String[] args){

    //调用

    Person(String name,int age){ }

    Person p =newPerson("lisi",20);

    }

}

class Person{

    private String name;

    private int age;

    Person(){}

    Person(String name){

        //调用

       Person(){ }

        this();

    }

    Person(String name,intage){

        //调用

       Person(String name){ }

        this(name);

        this.age=age;

    }

}

this语句只能定义在构造函数第一行.

5、static关键字

    用于修饰成员（成员变量和成员函数）

    被修饰后的成员具备以下特点

    （1）随着类的加载而加载，也就是说：静态会随着类的消失而消失，说明它的生命周期最长

    （2）优先于对象存在 

    （3）被所有对象所共享

    （4）可以直接被类名调用

使用注意

（1）静态方法只能访问静态成员

（2）静态方法中不可以写this，super关键字（先来后到）

         因为静态优先于对象存在，所以静态方法中不可以出现this、super

    （3）主函数是静态的

    实例变量和类变量的区别：

    （1）存放位置：

    类变量随着类的加载而存在于方法区中

    实例变量随着对象的建立而存在于堆内存中

    （2）生命周期：

    类变量生命周期最长，随着类的消失而消失

    实例变量生命周期随着对象的消失而消失

6、final关键字

    final修饰的类不可以被继承

    final修饰的变量是一个常量,只能被赋值一次.

    final修饰的方法可以被继承.不可以被覆盖

    内部类只能访问被final修饰的局部变量.

7、内部类

内部类的访问规则：

内部类可以直接访问外部类中的成员,包括私有。

因为内部类中持有了一个外部类的引用,格式外部类名.this

外部类要访问内部类,必须建立内部类对象。

如果要直接访问内部类中的成员,成员变量要写内部类的全名,要说明该内部类属于哪一个外部类.

注意匿名内部类的书写规范。

匿名内部类：

(1)匿名内部类其实就是内部类的简写格式。

(2)定义匿名内部类的前提：内部类必须是继承一个类或者实现接口。

(3)内部类的格式.：new父类或者接口( ){定义子类的内容}

(4)其实匿名内部类就是一个匿名子类对象。(定义类和建立对象封装在一起).可以理解为带内容的对象。

(5)匿名内部内中定义的方法最好不要超过3个。

8、单例设计模式

    单例设计模式：解决一个类在内存中只存在一个对象

    想要保证对象唯一：

    ·为了避免其他程序过多建立该类对象，先禁止其他程序建立该类对象

    ·还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象

    ·为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式

    异常的体系

    Throwable

Error

            通常出现重大问题如：运行的类不存在或者内存溢出等。

            不编写针对代码对其处理

Exception

            在运行时运行出现的一起情况，通过通过try catch finally

            Exception和Error的子类名都是以父类名作为后缀

    

    异常体系特点：

    异常体系中所有类以及建立的对象都具备可抛性。

    也就是说可以被throw和throws关键字所操作。

    Java在设计异常体系时，将容易出错的情况都封装成了对象。

    

    1、异常的处理：

    java提供了特有的语句进行处理.

    try

    {

        需要被检测的代码.

    }catch(异常类 变量){

        处理异常的代码(处理方式)

    }finally{

        一定会执行的语句.

}

    throws和throw的区别,

    throws使用在函数上,throw使用在函数内.

    throws后面跟异常类。可以跟多个，用逗号隔开。

    throw后跟的是异常对象。

    RuntimeException运行时异常

    在函数内抛出该异常,函数上可以不用声明的，编译一样通。

如果在函数上声明了该异常。调用者可以不用进行处理.编译一样通过。

    对多异常的处理。

    ·声明异常时，建议声明更为具体的异常，这样处理的可以更具体

    ·对方声明几个异常，就对应有几个catch块，不要定义多余的catch块

如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面

    建议在进行catch块处理时，catch中一定要定义具体处理方式

    不要简单定义一句 e.printStackTrace()，

    也不要简单地就就写一条输出语句

 

个人总结：

    重点就是理解并熟悉面向对象的思想，其实就如大家所说的一样，万物皆对象，一个好的面向对象的设计可以简化软件的开发！

其次面向对象里面的构造函数，构造代码块，静态代码块，异常处理等都十分重要！

要掌握面向对象三大特性：封装、继承、多态

 

                              ----------android培训、java培训、java学习型技术博客、期待与您交流！ ----------

                                                         详细请查看：http://edu.csdn.net/heima