黑马程序员------面向对象

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

1、面向对象是相对面向过程而言,面向对象和过程都是一种思想。

面向过程：强调的是功能行为； 面向对象：将功能封装成对象，强调具备功能的对象。

面向对象时基于面向过程的

面向对象的三大特征：封装（encapsulation）、继承（inheritance）、多态。

封装：提高了代码复用性和安全性

继承：提高了代码的复用性和扩展性，让类与类之间产生了关系（例如：多态的特性），类与类的继承是一种所属关系（即 “is a ” 的意思）

 

2、成员变量：一般存在于堆内存中，随着对象的的存在而存在，随着调用的完毕而成为垃圾，在不确定的时间被垃圾回收器回收。

局部变量：一般存在于栈内存中，随着调用的完毕而消失。

 

3、私有也是封装的一种表现形式。类中的私有属性一般都会有set（）、get（）方法，这是因为将属性私有化是为了防止非法操作，对外提供set()方法是为了通过逻辑判断控

制有效操作，提高代码健壮性！

 

4、构造函数：用来给对应的对象初始化，它的代码编写规则为：①函数名必须与类名一致；②不用定义返回值类型；③不可以写return语句。

注意：①多个构造函数是以重载的形式存在

      ②构造函数是在对象一建立就运行一个对象建立，构造函数只运行一次，而一般方法可以被该对象调用多次

构造代码块：用来给所有对象初始化，且优先于构造函数执行。形式为：{ ................ }。和构造函数的区别：构造代码块是给所有对象统一初始化，而构造函数是给对应的对象初始化

 

5、static：是一个修饰符，用于修饰成员（成员变量，成员函数）多一个调用方式：类名.静态变量

 

static特点：

①随着类的加载而加载；

②优先于对象建立；

③被对象所共享；

④可直接被类名调用。

 

6、final修饰符的作用：

①final修饰的类不能被继承；

②final修饰的方法不可以被复写；

③final修饰的变量为常量，且只能被赋值一次（包括成员变量和局部变量）。

 

7、this关键字的用法：

当定义类中功能时，该函数内部要用到调用该函数的对象时，这时用this来表示这个对象。但凡本类功能内部使用了本类对象，都用this。this用于构造函数之间相互调用。

this代表着本类的对象，this代表它所在函数所属对象的引用。

 

8、单例设计模式：是为了解决一个类在内存中只存在一个对象的问题。

设计思想：

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

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

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

方法：

①将构造函数私有化；

②在类中创建一个本类的静态私有对象；

③提供一个静态方法可以获取到该对象。

两种方式：

懒汉式：（推荐，因为它本身是线程安全的）Single类一进内存，就已经创建好了对象

class Single（）

{

         private static Single s = new Single();

         private Single(){}

         public static Single getInstance()

         {                

                   return s;

         }

}

 

饿汉式：也称为延时加载。Single类进内存的时候，对象还没存在，只有调用getInstance()方法时才建立对象。这里采用了加锁的双重判断方法来保证线程安全。

class Single

{

         private static Single s = null;

         private Single(){};

         public static Single getInstance()

         {

                 if (s==null)

                 {

                       Synchronized(Single.class)

                       {

                           If(s==null)

                           S = new Single();

                        }

                 }

                 return s;

         }

}

 

9、模板设计模式：如果在定义对象时，对象的一部分功能时确定的，但是有一部分是不确定的，而确定的部分在使用不确定的部分，那么这时候就将不确定的部分设计为抽象方法，并暴露出去。由子类继承父类，实现抽象方法。

例子：

abstract class GetTime

{

         public final long getTime()

         {

                   long start = System.currentTimeMillis();

                   runcode();

                   long end = System.currentTimeMillis();

                   return end-start;

         }

         public abstract void runcode();

}

class  Runtime1 extends GetTime

{

         public void runcode()

         {

                   for(int x = 0 ; x < 100 ; x++)

                   {

                            System.out.println("I love you , ZhongXincen ---"+x);

                   }

         }

}

class Demo

{

         public static void main(String[] args)

         {

                   Runtime1 r = new Runtime1();

                   System.out.println(r.getTime());

         }

}

10、定义接口和类的规律一般是：基本功能定义在类中，扩展功能定义在接口中。

接口中有常量和抽象方法，接口的成员都是public的，接口会自动给常量加上public static final前缀，给抽象方法加上public abstract前缀。

接口的特点：

①接口是对外暴露的规则

②接口是程序的功能扩展（提高了扩展性）

③可以用来多实现（降低了代码的耦合性，即关系降低）

④类与接口之间是实现关系，而且类可以在继承一个类的同时实现多个接口

⑤接口与接口之间为继承关系

接口：是不可以创建对象的，因为有抽象方法。需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化。否则子类是一个抽象类。

 

11、继承抽象类的子类，如果没有复写抽象类中的抽象方法，那么子类也是抽象类。当然抽象类中也可以不定义抽象方法，唯一的作用是不让类建立对象。

抽象方法一定存在于抽象类中，具有抽象方法的类一定是抽象类。

每个子类的构造函数默认第一行都有一条隐式语句super（）；

 

12、重载：只看同名函数的参数列表。
重写：子父类要一模一样。重写是指当子类和父类中出现了重名函数时，子类的函数会覆盖父类中的函数，也称为覆盖。

 

13、super和this：如果子父类中出现了非私有的成员变量，则使用子类中的重名成员变量时，用this引用（特例：当没有重名时，用this引用子类中没有而父类中有的非私有成员变量时，引用的是父类中的成员变量）。如果使用父类中的重名成员变量时，用super引用。

 

14、多态其实是父类引用指向了自己子类的对象，它也可以接收自己的子类对象。

不过当父类引用指向了自己的子类对象时，该子类对象的类型会被提升，称为“向上转型”。这样的话，如果要使用子类对象本身特有的方法时，要将父类的引用强制转换成子类类型（如果该父类有多个子类时，还要判断强转后的该父类引用是否是需要的子类对象）。

Public static void function (Animal a)     //多态

{

        A.eat();

        if(a instanceof Cat)         //如果是猫，得到它的抓老鼠功能

        {

            Cat c = (Cat)a;

            C.cat chMouse();

        }

       else if(a instanceof Dog)     //如果是狗，得到它的看家功能

       {

            Dog d = (Dog)a;

            d.kanJia();

       }

}

多态的前提是类与类之间要有关系，要么继承，要么实现。多态的局限性就是：它只能使用父类的引用访问父类中的成员。

 

15、异常：就是java对不正常情况进行描述后的对象体现，即java对程序运行时出现的问题进行描述，封装成了对象。

它分为：①严重问题：java通过Error类进行描述（一般不编写针对性的代码对其进行处理）

②非严重问题：java通过Exception类进行描述（可以使用针对性的处理方式进行处理）

异常的格式：

格式一：

try
{
需要被检测的代码；//如果执行过程中发生异常，那么发生异常那条语句之后的代码都不会执行，而直接进入catch块中处理异常。
}
catch(异常类 e)
{
处理异常的代码；（即处理方式）//要查看异常信息的话，使用e.printStackTrace();即可查看“异常名称：异常信息，异常出现的位置” 。这也是jvm默认的异常处理机制。
}
finally
{
一定会执行语句；
}

 

格式二：

try

{   }
catch

{   }

 

格式三：

try

{   }
finally

{   }

 

自定义异常必须继承Exception类，因为要使自定义异常具备可抛性。（这个可抛性是Throwable这个体系中独有特点，只有这个体系中的类和对象才可以被throws和throw操作）

throw和throws的区别：

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

throw后面跟的是异常对象，注意是“对象”，不是“类”。throw new Exception();

 

异常的分类：

①编译时被检测的异常，如果某个异常时检测时异常，就必须对其进行声明。

②编译时不被检测的异常，即运行时异常，包括RunTimeException及其子类。

 

RunTimeException是Exception中的一个特殊子类。因为如果在函数内抛出了该异常，函数上可以不用声明，编译一样能通过。如果在函数上声明了该异常，调用者可以不进行处理，编译一样能通过。因为，发生RunTimeException的时候，一般都是不可处理的。

 

异常在子父类中的覆盖问题：

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

②如果父类方法抛出多个异常，则子类在覆盖该方法时，只能抛出父类异常的子集；

③如果父类或接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常。也就是说即使子类在复写父类方法时产生了新的异常，也必须在内部用try{}处理，绝对不能抛。

 

异常的好处就是能让正常流程代码与问题处理代码相分离。