黑马程序员_java基础部分_面相对象一

　------- android培训、java培训、期待与您交流！ ----------

 

面向对象

对匿名对象，static、final、This关键字，构造代码块，静态代码块, 抽象类，继承，接口，单例设计模式，模板方法进行总结

1.         匿名对象使用方式一：

当对对象的方法只调用一次时，可以用匿名对象来完成，这样写比较简化。

如果对一个对象进行多个成员调用，必须给这个对象起个名字。

匿名对象使用方式二：

可以将匿名对象作为实际参数进行传递。

2.         面向对象：三个特征：封装，继承，多态。

以后开发：其实就是找对象使用,没有对象，就创建一个对象。找对象，建立对象，使用对象，维护对象的关系。

类和对象的关系。

现实生活中的对象：张三李四。

想要描述：提取对象中共性内容,对具体的抽象。

描述时：这些对象的共性有：姓名，年龄，性别，学习java功能。

类就是对现实生活中事物的描述。

对象就是这类事物实实在在存在个体。

其实定义类，就是在描述事物，就是在定义属性和行为,属性和行为共同成为类中的成员(成员变量和成员方法)。

成员变量和局部变量。

作用范围。

成员变量作用于整个类中。

局部变量变量作用于函数中，或者语句中。

在内存中的位置：

成员变量：在堆内存中，因为对象的存在，才在内存中存在。

局部变量：存在栈内存中

3.         对象一建立就会调用与之对应的构造函数。

构造函数的作用：可以用于给对象进行初始化。

构造函数的小细节：

当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数。

当在类中自定义了构造函数后，默认的构造函数就没有了。

 

构造函数和一般函数在写法上有不同。

在运行上也有不同。

构造函数是在对象一建立就运行,给对象初始化。

而一般方法是对象调用才执行，是给对象添加对象具备的功能。

 

一个对象建立，构造函数只运行一次。

而一般方法可以被该对象调用多次。

 

什么时候定义构造函数呢？

当分析事物时，该事物存在具备一些特性或者行为，那么将这些内容定义在构造函数中。

4.         构造代码块。

作用：给对象进行初始化。

对象一建立就运行，而且优先于构造函数执行。

和构造函数的区别：

构造代码块是给所有对象进行统一初始化，

而构造函数是给对应的对象初始化。

构造代码快中定义的是不同对象共性的初始化内容。

 

下面就是构造代码块的语法格式；

         {

         cry();

}

5.         this:看上去，是用于区分局部变量和成员变量同名情况。

this代表它所在函数所属对象的引用。

简单说：哪个对象在调用this所在的函数，this就代表哪个对象。     

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

6.         this语句:用于构造函数之间进行互相调用，它只用于构造函数之中；

this语句只能定义在构造函数的第一行，因为初始化内部有初始化要先执行内部的初始化。

 

7.         要想让这个类不能创建对象，那么我们就必须创建这个类里面的私有构造函数；

创建空参数私有的构造函数，以防止其他类创建本类对象；

private ArrayTool(){}

一般工具类里面都是静态的方法，所以不需要对外提供创建对象的方式；直接用类名调用；

8.         什么使用静态？

要从两方面下手，因为静态修饰的内容有成员变量和函数。

什么时候定义静态变量(类变量)呢？

当对象中出现共享数据时，该数据被静态所修饰。

对象中的特有数据要定义成非静态存在于堆内存中。

什么时候定义静态函数呢？

当功能内部没有访问到非静态数据(对象的特有数据)，

那么该功能可以定义成静态的。

9.         静态代码块的格式：

static

{

         静态代码块中的执行语句。

}

特点：随着类的加载而执行，只执行一次,并优先于主函数。

用于给类进行初始化的。

 

注意；静态代码块优先于构造代码块，构造代码块优先于构造函数；

10.     对静态的总结

静态：static。

用法：是一个修饰符，用于修饰成员(成员变量，成员函数).

当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，

还可以直接被类名调用,类名.静态成员。也就是说有两种调用方式；

static特点：

1，随着类的加载而加载。

   也就说：静态会随着类的消失而消失，说明它的生命周期最长。

2，优先于的对象存在

      明确一点：静态是先存在，对象是后存在的。

3，被所有对象所共享

4，可以直接被类名所调用。

实例变量（成员变量）和类变量（静态的成员变量）的区别：

1，存放位置。

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

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

2，生命周期：

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

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

静态使用注意事项：

1，静态方法只能访问静态成员。

         非静态方法既可以访问静态也可以访问非静态。

2，静态方法中不可以定义this，super关键字。

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

3，主函数是静态的。

静态有利有弊

利处：对对象的共享数据进行单独空间的存储，节省空间,没有必要每一个对象中都存储一份，可以直接被类名调用。

弊端：生命周期过长。

           访问出现局限性。(静态虽好，只能访问静态。)

11.     单例设计模式：解决一个类在内存只存在一个对象，创建单例对象分为三步；

1，将构造函数私有化。

2，在类中创建一个本类对象。

3，提供一个方法可以获取到该对象。

私有化构造函数；

private  Single01(){}

创建对象；

private static Single01 s = new Single01();

获取该类对象；

                  public static  Single01 getInstance()

{

return s;

         }

12.     单例设计模式还有一种设计方式；称之为懒汉式

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;

13.     抽象类的特点：

1，抽象方法一定在抽象类中。

2，抽象方法和抽象类都必须被abstract关键字修饰。

3，抽象类不可以用new创建对象,因为调用抽象方法没意义。

4，抽象类中的抽象方法要被使用，必须由子类复写里面的所有抽象方法后，建立子类对象调用，如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。

5，建立抽象类的子类对象，还可以调用抽象类的特有方法，要是子类有和抽象类中的特有方法一致的非抽象方法，那么就是覆盖，调用时，只运行父类中的方法；

抽象类和一般类没有太大的不同。

该如何描述事物，就如何描述事物，只不过，该事物出现了一些看不懂的东西。

这些不确定的部分，也是该事物的功能，需要明确出现。但是无法定义主体。

通过抽象方法来表示。

 

抽象类比一般类多个了抽象函数，就是在类中可以定义抽象方法。

抽象类不可以实例化。

 

特殊：抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。

abstract 关键字，和哪些关键字不能共存。

final：被final修饰的类不能有子类，而被abstract修饰的类一定是一个父类。

private: 抽象类中的私有的抽象方法，不被子类所知，就无法被复写。

                   而抽象方法出现的就是需要被复写。

static：如果static可以修饰抽象方法，那么连对象都省了，直接类名调用就可以了。

                   可是抽象方法运行没意义。

抽象类中是否有构造函数？

有，抽象类是一个父类，要给子类提供实例的初始化。

14.     继承的特点；

Java语言中：java只支持单继承，不支持多继承。

因为多继承容易带来安全隐患:当多个父类中定义了相同功能，

当功能内容不同时，子类对象不确定要运行哪一个。

但是java保留这种机制。并用另一种体现形式来完成表示,多实现。

java支持多层继承。也就是一个继承体系

如何使用一个继承体系中的功能呢？

 

想要使用体系，先查阅体系父类的描述，因为父类中定义的是该体系中共性功能。

通过了解共性功能，就可以知道该体系的基本功能。

那么这个体系已经可以基本使用了。

那么在具体调用时，要创建子类的对象，为什么呢？

一是因为有可能父类不能创建对象，

二是创建子类对象可以使用更多的功能，包括基本的也包括特有的。

简单一句话：查阅父类功能，创建子类对象使用功能。

创建子类对象，我们就可以直接使用父类的定义的方法和变量；

15.     子父类出现后，类成员的特点：

类中成员：

1)         变量。

如果子类中出现非私有的同名成员变量时，

子类要访问本类中的变量，用this

子类要访问父类中的同名变量，用super。

super的使用和this的使用几乎一致。

this代表的是本类对象的引用。

super代表的是父类对象的引用。

2)         函数。

当子类出现和父类一模一样的函数时，

当子类对象调用该函数，会运行子类函数的内容。

如同父类的函数被覆盖一样。

这种情况是函数的另一个特性：重写(覆盖)

当子类继承父类，沿袭了父类的功能，到子类中，

但是子类虽具备该功能，但是功能的内容却和父类不一致，

这时，没有必要定义新功能，而是使用覆盖特殊，保留父类的功能定义，并重写功能内容。

覆盖：

1，子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。

2，静态只能覆盖静态。

记住大家：

重载：只看同名函数的参数列表。

重写：子父类方法要一模一样。

 

在子类的方法中可以通过super来调用父类的方法；

void speak()

{

子类可以通过super来调用父类的方法；

super.show();

子类和父类的同名函数，存在覆盖，只会执行子类内容；

System.out.println("java");

}

3)         构造函数。

子类的所有的构造函数，默认都会访问父类中空参数的构造函数。

因为子类每一个构造函数内的第一行都有一句隐式super();

当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问父类中的构造函数。

当然：子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。

子类中至少会有一个构造函数会访问父类中的构造函数。

我们每创建一个子类对象的时候,就会调用子类的构造方法,以及父类的构造方法;

16.     final : 最终。作为一个修饰符，

1，可以修饰类，函数，变量。

2，被final修饰的类不可以被继承,为了避免被继承，被子类复写功能。

3，被final修饰的方法不可以被复写。

4，被final修饰的变量是一个常量只能赋值一次，既可以修饰成员变量，有可以修饰局部变量。

当在描述事物时，一些数据的出现值是固定的，那么这时为了增强阅读性，都给这些值起个名字，方便于阅读。

而这个值不需要改变，所以加上final修饰，作为常量：常量的书写规范所有字母都大写，如果由多个单词组成，单词间通过_连接。

5，内部类定义在类中的局部位置上时，只能访问该局部被final修饰的局部变量。        

17.     接口：初期理解，可以认为是一个特殊的抽象类

当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。

class用于定义类

interface 用于定义接口。

接口定义时，格式特点：

1，接口中常见定义：常量，抽象方法。

2，接口中的成员都有固定修饰符。

常量：public static final

方法：public abstract

记住：接口中的成员都是public的。

接口：是不可以创建对象的，因为有抽象方法。

需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化。

否则子类是一个抽象类。

接口可以被类多实现，也是对多继承不支持的转换形式。java支持多实现。

 

访问接口中的变量有三种形式；

//这个是可以通过三种方式调用，通过类调用，通过对象调用，通过接口调用；System.out.println(t.NUM);

System.out.println(Test.NUM);

System.out.println(Inter.NUM);

18.     什么是模版方法呢？

在定义功能时，功能的一部分是确定的，但是有一部分是不确定，而确定的部分在使用不确定的部分，那么这时就将不确定的部分暴露出去，由该类的子类去完成，就是模板设计方法；

abstract class GetTime

{

 

//      这部分是确定的功能，确定的代码；它不能被复写；所以我们加上final；

         public final void getTime()

         {

                   long start = System.currentTimeMillis();

                   runcode();

                   long end = System.currentTimeMillis();

                   System.out.println("毫秒："+(end-start));

         }

//      这部分是不确定的功能，确定的代码；然后让你暴漏出去；

         public abstract void runcode();

}

class SubTime extends GetTime

{

//复写不确定代码的成分；

         public void runcode()

         {

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

                   {

                            System.out.println("x");

                   }

         }

}

class  TemplateDemo

{

         public static void main(String[] args)

         {

//               子类去调用父类的特有方法，很好，这个就是模板设计模式；

                   SubTime gt = new SubTime();

                   gt.getTime();

         }

}