黑马程序员-面向对象

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

面向对象是相对面向过程而言的

面向过程强调的是功能行为。

面向对象：将功能封装进对象，强调具备了功能的对象

 

比如猫，功能行为。猫叫，猫跑，吃东西。而对象的话则把这些功能封装在猫对象当中，调用的时候调用的是猫对象中的这些功能。

 

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

找对象，建立对象，使用对象，维护对象的关系。

 

类和对象的关系

类就是对现实生活中事物的描述。就是在定义类的属性和行为。

属性对应的就是类中的变量，行为对应的类中的方法。

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

 

堆内存中的特点：默认初始化值

 

成员变量和局部变量

作用范围：

成员变量作用在整个类中；局部变量作用在函数中，或者语句中。

在内存中的位置

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

 

匿名对象：

匿名对象是对象的简写格式。

匿名对象两种使用情况

匿名对象方法仅进行一次调用时，当对一个对象进行多次成员调用，必须给该对象起个名字

匿名对象可以作为实际参数进行传递，即调用属性无意义，调用方法有意义

Car c = new Car()  c.num = 5;

匿名对象写为 new Car().num = 5;

 

封装

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

好处：

将变化隔离   便于使用  提高重用性  提高安全性

封装原则：

将不需要对外提供的内容隐藏起来。

把属性都隐藏，提供公共方法对其访问。

Private：私有，权限修饰符。用于修饰类中的成员（成员变量，成员函数）

当属性私有化后需要调用，则需要通过调用方法来实现。

私有只在本类中有效

封装不是私有。私有仅仅是封装的一种表现形式。权限在你访问不到的情况下就是封装。

之所以对外提供访问方式，就是因为可以在访问方式中加入逻辑判断等语句，对访问的数据进行操作，提高代码的健壮性。

构造函数-----对象一建立就会调用与他对应的构造方法

特点：

函数名与类名相同。  不用定义返回值类型。  不可以写return语句

作用：

给对象初始化。

注意：

默认构造函数的特点。

多个构造函数是以重载的形式存在的

 

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

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

 

构造函数和一般函数除了写法不同，在运行上也有不同。

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

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

 

2. 一个对象建立，构造函数只执行一次，而一般方法可以被该对象调用多次

 

什么时候定义构造函数：

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

 

构造代码块

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

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

和构造函数的区别。

构造代码块是给什么对象进行统一初始化，而构造函数给给对应的对象初始化。

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

{

system.out.println()

}

 

this关键字

看上去是用于区分局部变量和成员变量同名的情况

特点：this代表本类的对象，this代表他所在函数，所属对象的引用。哪个对象在调用this所在的函数，this就代表哪个对象

应用：

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

 

this在构造函数间调用。

this() 语句  用于构造函数间互相调用，只能定义在构造函数的第一行

 

static(静态)

用于修饰成员(成员变量和成员函数)

被修饰的成员有以下特点：

随着类的加载而加载；

优先于对象存在

被所有对象所享用

可以直接被类名调用

 

实例变量和类变量的区别

1.存放位置

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

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

2.生命周期

类对象：生命周期最长，随着类的消失而消失。

实例对象：随着对象的消失而消失

当成员被静态修饰后，就多了一种调用方式，除了可以被对象调用外，还可以直接被类名调用。类名.静态成员

 

注意使用：

静态方法只能访问静态成员，非静态方法即可以访问静态也可以访问非静态

静态方法中不可以写this, super关键字，因为静态优先于对象存在

主函数是静态的

 

静态的利与弊

利：对对象的共享数据进行单独空间的存储，节省空间，没有必要每一个对象都存储一份

         可以直接被类名调用。

弊：生命周期过长。访问出现局限性。(只能访问静态)

 

什么时候使用静态

静态修饰的有成员变量和函数。所以从这两方面下手。

什么时候定义静态变量

当对象中出现共享数据时，该数据被静态所修饰，对象中的特有数据要定义成非静态存在于堆内存中。

什么时候定义静态函数。

当功能内部没有访问到非静态数据(功能没操作对象的特有数据），那么该功能可以定义成静态的。

 

主函数

是一个特殊的函数。作为程序的入口，可以被jvm调用

主函数的定义：

Public 代表该函数的访问权限是最大的。

Static 代表主函数随着类的加载就已经存在了。

Void 主函数没有具体的返回值。

Main 不是关键字，但是是一个特殊单词。可以被jvm识别。

（String [] args）函数的参数，参数类型是一个数组，该数组的元素是字符串

 

Jvm在调用主函数时，传入的是newString[0];

 

 

帮助文档的制作

//java的说明书。通过文档的注释来完成

1.      /**  

2.      这是一个可以对数组操作的工具类，该类提供了，获取最值，排序，等功能

3.      @auther 作者 @version 版本

4.      Class ArrayTool {

PrivateArrayTool() {}

5.      /**

Public static  int getMax() {

         Int max = 0;

         for(int x=1; x<arr.length; x++) {

if(arr[x]>arr[max]){

         max = x;

}

return arr[max];

}

6.      获取一个整形数组的最大值

7.      @param arr 接受一个int类型的数组

8.      @return 会返回一个该数组的最大值

9.      }

10.  */

11.  }

12.  */

当文档写完，需要调用javadoc –d 存放目录–auther –version XXX.java(源文件)

若出现：错误- 找不到可以文档化的公共或者受保护的类即类没有被public修饰

 

一个类中默认会有一个空参数的构造函数，

这个默认构造函数的权限和所属类一致，

如果类被public 修饰，那么默认的构造函数也带public修饰

如果类没有被public 修饰，那么默认的构造函数也没有public修饰

 

 

 

 

静态代码块

格式

Static {

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

}

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

用于给类进行初始化。

 

对象的初始化过程

Person p =new Person(“zhangsan”, 20);这句话做了什么事情

1.      New用到了Person.class，所以先找到Person.class文件并加载到内存中

2.      是否有static代码块，若有，则对类进行初始化

3.      在堆内存中开辟空间，分配内存地址

4.      在堆内存中建立对象的特有属性，并进行默认初始化

5.      对属性进行显示初始化

6.      是否有构造代码块对对象进行初始化

7.      进行构造函数的初始化

8.      将内存地址付给栈内存的P变量

 

 

设计模式：解决一类方法最行之有效的方法

 

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

想要保证对象唯一。

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

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

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

代码体现：

1.      将构造函数私有化

2.      在类中创建一个本类对象

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

 

对事物该怎么描述还怎么描述。当需要将该事物的对象保证在内存的唯一时，就将以上三步加入即可

 

 

饿汉式

class Single {

         privateString name;

         publicvoid setName(String name){

                   this.name= name;

         }

        

         publicString getName(){

                   returnname;

         }

        

         privateSingle(){}

        

         privatestatic Single s = new Single();

        

         publicstatic Single getInstance(){

                   returns;

         }

}

 

class SingDemo {

         publicstatic void main(String[] args) {

                   Singles1 = Single.getInstance();

                   Singles2 = Single.getInstance();

                   s1.setName("lisi");

                   System.out.println(s2.getName());

         }

}

 

 

懒汉式

 

class Sing{

         privateSing() {}

         privatestatic   Single s = null;

         publicstatic Single getInsatance() {

                   if(s==null)

                            s= new Single;//对象是方法被调用时，才初始化，也叫做

                                                                                                       //对象的延时加载，称为：懒汉式

                   returns;

         }

}

 

饿汉式：Single类一进内存，就已经创建好对象  //建议使用饿汉式

懒汉式：Single类进内存，对象还没有存在，只有调用了getInstance方法时，才建立对象，

缺点：如果多个人同时调用容易发生问题。执行着的时候突然停止，执行其他线程。多线程

 

继承：

1.      提高了代码的复用性

2.      继承让类与类之间产生了关系，有了关系才有了多态的特性

 

注意：千万不要为了获取其他类的功能，简化代码而继承

必须是类与类之间有所属关系才可以继承，所属关系 is a (父子关系)

 

Java只支持单继承，不支持多继承，因为多继承存在安全隐患，当多个父类中定义了相同功能，当功能内容不同时，不知道调用哪一个。

Java支持多层继承 ：爷 父 子 也就是一个继承体系。

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

想要使用体系，先查阅父类的描述。因为父类中定义的是该体系中共性功能。通过了解共性功能，就可以知道该体系的基本功能。那么这个体系已经可以基本调用了。在具体调用时，要创建最子类的对象。为什么呢。一是因为有可能父类不能创建对象，二是创建子类对象可以使用更多的功能，包括基本的也包括特有的。

简单的说：查阅父类功能，创建子类对象使用

 

聚集谁里面有谁    继承谁是谁的一种

聚合，组合 (紧密联系程度不同)

聚合: 球队由球队组成。

组合：手是身体的一部分。

 

子父类中成员的特点

类中成员：

1.      变量

2.      函数

3.      构造函数

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

子类要访问本类中的变量，用this  代表本类对象的引用。

子类要访问父类中的同名变量，用super 代表的是父类对象的引用

函数：

当子类对象出现和父类一模一样的函数时，子类对象调用该函数时，会运行子类函数的内容。

如同父类的函数被覆盖一样。这种情况是函数的另一个特性：重写（覆盖）

 

当子类继承了父类，沿袭了父类的功能到子类中，但是子类虽具备该功能，但功能的内容却和父类不一致，这时，没有必要定义新功能。而是使用覆盖特性，保留父类功能，并重新定义功能方法。‘

 

覆盖：

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

静态只能覆盖静态。

 

构造函数：

在对子类对象进行初始化时，父类的构造函数也会运行。

那是因为子类的构造函数默认第一行有一条隐式的语句super();

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

 

子类的所有构造函数都会访问父类中空参数的构造函数。因为子类每一个构造函数内的第一行都有一句隐式super()；  当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问父类中的构造函数

 

Final关键字

可以修饰类，方法，变量

Final修饰的类不可以被继承，

修饰的方法不可以被覆盖。

Final修饰的变量是一个常量，只能被赋值一次。

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

 

抽象类

当多个类中出现了相同功能，但是功能主体不同，这时可以进行向上抽取，这时，只能抽取功能定义，，不能抽取功能主体。

抽象类的特点

抽象方法一定在抽象类中

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

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

抽象类中的方法要被调用，必须由子类复写起所有的抽象方法后，建立子类对象调用。

如果子类只能覆盖部分抽象方法，那么该子类还是一个抽象类

 

接口：

初期理解。可以认为是一个特殊的抽象类

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

Class 定义类   interface定义 接口

接口定义时格式特点。

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

2 接口中的成员都有固定修饰类

     常量 public static final

         方法publicabstract

 

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

 

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

 

 

多态：

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

动物：猫，狗

猫  X = new 猫();

动物 X = new 猫();  //类型提升。向上转型

如果要想调用猫的特殊方法//强制将父类的引用，转成子类类型。 猫c = (Cat)a  向下转型

千万不要出现这样的操作  ，将父类对象转换成引用类型。

Animal a = new Animal();

Cat c = (Cat)a

判断某一类型引用指向的到底符合什么类型。If( a instanceof  Cat )谁的实例

Instanceof一般两种情况下使用

第一种：子类类型有限（男人，女人）

第二种：当传的类型需要进行其他操作时，比如比较。必须得确认他到底是哪种子类类型，要调用他特有方法的比较

1.      多态的体现。

父类的引用指向了自己的子类对象。父类的引用也可以接收自己的子特殊类对象

2.      多态的前提

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

通常存在覆盖

3.      多态的好处

         大大的提高了程序的扩展性

 

4.      多态的弊端

提高了扩展性，但只能引用父类的引用访问父类的成员。

 

5.      多态的应用

 

6.      多态使用的注意事项

 

7.      在多态中(父类指向子类对象)(非静态) 成员函数的特点

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

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

         简单总结就是成员函数在多态调用是，编译看左边，运行看右边

8.      在多态中，成员变量的特点。

无论编译运行，都参考左边(引用类型所属的类)。也就是当父类和子类当中出现重名变量时，多态情况看的是左边。

        

9.      在多态中，成员变量的特点。

无论编译还是运行都参考左边。静态方法，当在调用时，都会加载到内存，就存在在内存中。

 

Object类

所有对象直接或者间接的父类。该类中定义的是所有对象定义的功能

 

 

内部类

将一个类定义在另一个类的里面，里面那个类称为内部类

访问特点

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

而外部类要访问内部类中的成员必须建立内部类对象

 

访问格式

1 当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中，直接建立内部类对象

格式

         外部类名.内部类名  变量名 = 外部类对象.内部类对象

         Outer.Interin = new Outer().new Inter();

2 当内部类在成员位置上，可以被成员修饰符修饰，

         Static      内部类就具备了静态的特性

         Private将内部类在外部类中进行封装

 

静态内部类

当内部类被static修饰后，只能直接访问外部类中的static成员

在外边其他类中。如何直接访问static内部类的非静态成员呢

New Outer.Inter().function();

 

当内部类中定义了静态成员，该内部类必须是静态的

当外部类中的静态方法访问内部类时，内部类也必须是静态的

 

何时使用

当描述事物时，事物的内部还有事物，该事物用内部类描述。

因为内部事物在使用外部事物的内容

 

内部类定义在局部时

1 不可以被成员修饰符修饰

2 可以直接访问外部类中的成员，因为还持有外部类中的引用。但是不可以访问他所在局部中的变量，只能访问被final修饰的局部变量

 

匿名内部类

1 其实就是内部类的简写格式

2 前提：内部类必须继承一个类或者实现接口