------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ ----

黑马程序员     面向对象

面向对象的概念:在程序中使用对象来映射现实中的事物,适用对象的关系来描述事物之间的联系,这种思想就是面向对象.

       特点分为:封装性:封装是面向对象的核心思想,将对象的属性和行为封装起来,不需要让外界知道具体实现细节.

                         继承性:主要描述类与类之间的关系,通过继承,可以再无需重新编写原有类的情况下,对原有类的功能进行扩展.

                         多态性:在程序中允许出现重名现象.

类和对象:1)类是对现实世界的描述.

                  2)对象时现实中存在的个体.

成员变量和局部变量:

                 1)作用范围:局部变量在方法内,成员变量在类中.

                  2)存储空间:局部变量在栈中,成员变量在堆中.

                   3)初始化值:局部变量人工初始化赋值,成员变量jvm默认初始化

匿名对象的使用:对对象中的功能值执行一次的时候使用,否则没有名字.

                              勇于作为实际参数进行传递

封装:    把属性隐藏仅对外提供公共的访问方法.

            好处: 便于重复使用,安全性高.

private:1)可以再方法中对成员变量的访问进行控制.私有只是封装的一种体现形式.

             2)常用方法:void setAge(int  a) {}int getAge(){}

匿名内部类

    匿名内部类就是内部类的简化写法。

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

    格式为：

new 外部类名或者接口名（构造函数参数）{

 覆盖类或者接口中的代码，也可以自定义内容

}.方法（）;

    简而言之：就是建立一个带内容的外部类或接口的子类匿名对象

    匿名内部类中定义的方法最好不要超过2个。

 

当调用的方法的参数是一个接口时，当这个接口的方法小于3个时，可以用匿名内部类。

 

 

异常

异常的体系

Throwable：Error，Exception

 

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

      Throwable中的方法：

getMessage()：获取异常信息，返回字符串

toString() : 获取异常类名和异常信息，返回字符串

printStackTrace() : 获取异常类名和异常信息，以及异常出现在程序中的位置，返回值void

printStackTrace(PrintStream s) : 通常用该方法将异常内容保存在日志文件中，以便查阅

 

十一.       throws和 throw

       throws用于标识函数暴露出的异常

       throw用于抛出异常对象

 

       throws和throw的区别：

       throws用在函数上，后面跟异常类名

       throw用在函数里，后面跟异常对象

      

      

 

 

十二.       异常处理：

       try{

              需要检测的代码；

}catch(异常类 变量){

       异常的处理代码；

}finally{

       一定执行的代码；

}

finally只有一种情况下不会执行，就是在之前执行了System.exit(0);

 

十三.       多异常处理

       调用的方法中抛出几个异常，就应该有几个catch进行捕获。不要定义多余的catch块。建议在进行catch处理时，catch中一定要定义具体的处理方式。不要简单的定义一句e.printStackTrace();

 

十三.       自定义异常

       自定义异常类继承Exception类或者其子类

       通过构造方法定义异常信息

       class       DemoException extends Exception{

              DemoException(Stringmessage){

                     super(message);

}

}

       通过throw将自定义异常抛出

       throw new 自定义异常类名（）;

       当在函数内部出现了throw抛出异常对象，那么就必须要给对应的处理动作。要么在内部try catch处理。要么在函数上声明让调用者处理。一般情况下，函数内出现异常，函数上需要声明。

       因为父类中已经把异常信息的操作已经完成了，所以子类只要在构造时，将异常信息传递给父类通过super语句。那么就可以直接通过getMessage()方法获取自定义的异常信息了。

      

       继承Exception原因：

       异常体系有一个特点：因为异常类和异常对象都被抛出。他们都具备可抛性，这个可抛性是Throwable这个体系中独有特点。

       只有这个体系中的类和对象才可以被throws和throw操作。

      

       throws和throw的区别：

       throws：使用在函数上。后面跟异常类，可以跟多个，用逗号隔开。

       throw ：使用在函数内。后面跟异常对象。

 

十四.       异常细节 

       Exception中有一个特殊的子类异常RunTimeException运行时异常。

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

       之所以不用在函数上声明，是因为不需要让调用者处理。当该异常发生，希望程序停止。因为在运行时，出现了无法继续运算的情况，希望停止程序后，对代码进行修正。

      

       自定义异常时：如果该异常的发生，无法在继续进行运算，就让自定义异常继承RunTimeException

 

       对于异常分为两种：

    编译时被检测的异常。

    编译时不被检测的异常（运行时异常。RunTimeException以及其子类）

 

格式1：

try{

}catch(){

}

 

格式2：

try{

}catch(){

}finally{

}

 

格式3：

try{

}finally{

}

//catch是用来处理异常，如果没有catch就挖根挨批凤有被处理过，如果该异常是检测时异常。那么必须声明。

 

 

异常在子父类覆盖中的体现：

    子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的异常或者该异常的子类。

    如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子集。

    如果父类或者接口的方法中，没有异常抛出。那么子类在覆盖方法时也不可以抛出异常。如果子类方法发生了异常，就必须要进行try处理。绝对不能抛。

 

十五.       包（package）

       包是一种封装形式

      

       编译时加参数，如：javac –d . 类名

      

类名的全称：包名.类名

 

       被访问的包中的类权限必须是public的。类中的成员权限：public和protected

       protected是为其它包的子类提供的一种权限

      

       权限

                     public                   protected                           default                  private

       同类          Y                              Y                             Y                             Y

       同包          Y                              Y                             Y

       子类          Y                              Y

       不同包       Y

      

       一个类文件中只能有一个public修饰的类

       导入包：import 包名.类名

       如果要导入包下所有的类，即包名.*，但不包括子包中的类

      

       当导入的包中，存在重名的类时。调用时用：包名.类名 的方法

 

十六.       Jar包

       需要执行jar包中的类时，把jar文件路径放至classpath环境变量中

版权声明：本文为博主原创文章，未经博主允许不得转载。

1.面向对象是相对于面向过程而言的。（1）面向过程强调过程，执行者。（2）面向过程强调过程，指挥者。我让你帮我买烟，就是面向对象。我自己去买烟就是面向过程。（3）面向对象的特点：a.封装b.继承c.多态

2.类和对象:(1)类是对现实世界的描述。（2）对象是现实中存在的个体。

3.成员变量和局部变量（1）作用范围：局部变量在方法内，成员变量在类中。（2）存储空间：局部变量在栈中，成员变量在堆中。（3）初始化值：局部变量人工初始化赋值，成员变量jvm默认初始化。 

4.匿名对象的使用（1）对对象中的功能只执行一次的时候使用，否则用有名字对象。（2）勇于作为实际参数进行传递。

5.封装：把属性隐藏仅对外提供公共的访问方法。（1）好处：便于重复使用，安全性高。

6.private：（1）可以早方法中对成员变量的访问进行控制。私有只是封装的一种体现形式。（2）常用方法：void setAge(int a){}int getAge(){}
  class Demo{
   int age;//把属性私有对外提供公共的访问方法,可控性提高了

public void setAge(int age){//age = -20;
    if(age>=0 && age<=200){
     this.age = age;
    }
    else { 
     System.out.println("请回火星");
    }
   }   public int getAge(){
    return age;
   }
  }
  class DemoTest{
   public static void main(String[] args) {
    Demo d = new Demo();
    d.setAge(-20);
    System.out.println(d.getAge());
   }
  }

7.构造函数特点：（1）方法名必须与类名相同（2）构造函数没有返回值也不能定义为void，方法名前不声明方法类型（3）构造方法不能有编程人员调用而是由系统调用（4）一个类可以定义多个构造方法（5）若没定义构造函数系统会给一个默认的无参构造函数（6）给对象初始化，一建立对象系统就会自行调用

8.class Person{
  int age;
  String name;
  Person(){}
  Person(int age,String name) {//age = 20,name = "zhangsan";
   this.age = age;
   this.name = name;
  }
  public void speak(){
   System.out.println(age + "....." + name);
  }
}
class Demo{
 public static void main(String[] args) {
  //Person p = new Person(20,"zhangsan");
  Person p = new Person();
  p.speak();
 }
}

9.this关键字：哪个对象调用this所在的函数this就代表了那个对象。作用：（1）函数参数或者函数中的局部变量和成员变量同名的情况，用this.成员变量名来引用成员变量。（2）在函数中需要引用该函数所属类的当前对象时候直接用this（3）this（参数列表）在一个构造函数中调用另一个构造函数用这种this语句（只可放在构造函数第一行）。

Person(String name){
   this.name = name;
  }

  Person(String name,int age){
   
   this("张三");//是找带一个字符串类型参数的构造方法
   this.name = name;
   this.age = age;
   //this("zhangsan");

  }
  Person p = new Person("lisi",20);

10.代码块：（1）局部代码块定义在方法里，可以控制变量的生命周期（2）构造代码块定义在类里，每创建一次对象就执行一次（3）静态代码块给类进行初始化，只在第一次new执行一次。Person p =new Person的过程中在内存做了什么：a.将Person.class加载进内存b.p定义函数中，在栈内存中开辟了变量空间pc.在堆内存中分配空间并分配内存地址值，d.给对象中的属性进行默认初始化额e.给对象中的值进行显示初始化f.调用构造代码块对对象进行初始化g.调用构造函数进行初始化h.将对象的内存地址值赋值给p变量，让p变量指向该对象。

11.static静态用于修饰成员变量，成员被静态修饰后可以直接用：类名.静态成员调用。静态特点：随类的加载而加载，生命周期长。优先于对象存在。被所有对象共享。静态变量都被存储在方法区。实例变量是非静态成员变量，类变量是静态变量。类变量随类的加载存在于方法区，实例变量随对象的建立存在于堆中。类变量所属于整个类，被所有对象共享，实例变量是对象的特有数据。要注意：1）静态方法只可以访问静态成员，非静态方法既可以访问静态页可以访问非静态。2）静态方法中不可以定义this super关键字因为静态优先于对象存在，所以静态方法中不可以出现this。静态的利弊：对对象的共享数据提供单独的存储空间，不用每个对象都存一份节约内存，可以类名.直接调用。生命周期过长，静态虽好，只可访问静态。什么时候可以使用静态：成员变量所存储的数据每个变量否拥有这个数据，没必要存储到对象中，让所有对象共享该数据即可，用static修饰。什么时候定义静态函数：当成员函数没有访问对象的特有数据是，就将该方法定义成静态的，该方法没有访问到静态的特有数据，直接类名.调用即可。

12.单利设计模式：饿汉式：1）私有构造函数2）创建一个本类对象3）定义一个公共的访问方式：        class Single {
 private Single() {}
 private static Single s = new Single ();
 public static Single getInstance(int num) {
  return s;
 }

懒汉式：1）私有构造函数2）声明一个本类引用3)定义一个公共的访问方式

class Single {
         private Single() {}
         private static Single s;
         public static Single getInstamce (int num) {
          if (s==null) {
              s = new Single();
           }
          return s;
         } 
     }