黑马程序员-面向对象的学习总结-1

1、什么叫面向对象？

面向对象是一种常见的程序结构设计方法,面向对象的基础是面向过程，面向过程强调的是功能，面向对象是将功能封装进对象，强调的是具备功能的对象。

 

面向对象的三个特征：

封装(Encapsulation);

继承(Inheritance);

多态(Polymorphism)。

 

2、类

类的概念
类是一组事物共有特征和功能的描述。类是对于一组事物的总体描述，是按照面向对象技术进行设计时最小的单位，也是组成项目的最基本的模块。类的概念是抽象的，类似于建筑设计中的图纸，是对于现实需要代表的具体内容的抽象。类只包含框架结构，而不包含具体的数据。所以类代表的是总体，而不代表某个特定的个体。

 

类的定义：

[修饰符] class  类名{

  1~n个构造方法；

0~n个字段；

0~n个方法

}

 

3、构造方法

构造方法：用来构造类的实例（每一个类都默认有一个无参的构造方法，得使用new调用）

字段：类或对象所包含的数据，对类状态的一种描述；

方法：类或对象的特征或行为

 

作用：

给类中的字段进行初始化，可以用来创建对象。

 

特点：

方法名与类名相同

不用定义返回值类型 

不需要写return语句

 

构造方法的重载:（需要哪个就去适配哪个，调用哪个）

this([实参]);调用当前类的构造方法

注意: this([实参]);必须放在构造器的第一行;

  

对象的产生格式：

类名称  对象名 = new  类名称();

因为有(),所以是方法,实际上它就是构造方法，并且是非私有的构造方法。 

示例代码：

class Person{      private String name;      private int age;          public void show(){          System.out.println("："+name+age);      }      public Person(String name) {          super();          this.name = name;      }      public Person(String name, int age) {          super();          this.name = name;          this.age = age;      }  } <span style="color:#c0c0c0;"> </span>

 4、static关键字

 

特点：随着类的加载而加载、优先于对象存在、被所有对象所共享、可以直接被类名调用。

注意：静态方法只能访问静态成员、但是非静态成员可以访问静态成员、静态方法中不可以使用this，super关键字、主方法（main）是静态的（可以利用类名去调用静态的main方法，很正常！但是会陷入死循环，导致内存溢出，jvm自动停止！）public static void main(String[] agrs){}。

用static 修饰的成员表示它属于这个类共有，而不是属于该类的单个实例。

static 修饰的字段 == 类字段

static 修饰的方法 == 类方法

没使用static修饰的字段和方法，成员属于类的单个实例，不属于类。

没有static 修饰的字段 == 实例字段

没有static 修饰的方法 == 实例方法

类和实例访问字段和方法的语法：

访问类成员：类.字段     类.方法

访问实例成员：实例.字段     实例.方法

 

5、匿名对象

理解：一个没有名字的对象,  创建了一个对象出来,没有赋给一个变量;

特点：对方法或字段只进行一次调用时；可作为实际参数进行传递；只在堆里面开辟存储区域,

注意：只能使用一次,  使用完就被销毁了;

new Person();表示匿名对象,没有名字的对象

new Person().age = 17;//使用一次之后就被销毁了

 

6、this关键字

特点：this表示当前对象，当前正在调用实例成员的对象（谁调用了方法，谁就是当前对象）。

this关键字的使用：

方法间的相互调用;

this.字段;

构造器中相互调用，但是此时this([参数])必须写在构造方法第一行。

注意：this不能用在static修饰的方法里和static修饰的代码块里。

 

7、面向对象---封装

 

封装的两个含义：

1.把对象的状态和行为看成一个统一的整体，将二者存放在一个独立的模块中(类)；

2."信息隐藏", 把不需要让外界知道的信息隐藏起来,尽可能隐藏对象功能实现细节,字段; 

封装机制在程序中的体现是：把描述对象的状态用字段表示，描述对象的行为用方法表示，把字段和方法定义在一个类中，并保证外界不能任意更改其内部的字段值，也不允许任意调动其内部的功能方法。

程序中的一种体现：通常将类中的成员变量私有化(private)，通过对外提供方法（setXxx,getXxx）,可对该变量(xxx)进行访问（boolean 类型的变量没有getXX,只有 isXX）。

 

示例代码：

class Person{      private String name;      private int age;          public void show(){          System.out.println("："+name+age);      }      public Person(String name) {          super();          this.name = name;      }      public Person(String name, int age) {          super();          this.name = name;          this.age = age;      }  }  

 8、面向对象---继承

 

首先有反映一般事物特性的类,然后在此基础上反映出特殊事物的类；

也就是说：继承是一种从一般到特殊的关系；

 

特点：

1、提高了代码的复用性。

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

3、Java语言中只支持单继承（有别于C语言）。

因为多继承容易带来安全隐患（父类多了， 功能相同的话，就会出现调用不确定性吗，覆写一个方法，到底覆写的谁的？）。

4、Java支持多层继承，object是每个类的超类，实现树形结构。

格式：[修饰符] class SubClass extends SuperClass

SuperClass类为父类或基类，SubClass为子类或派生类或拓展类；（java.lang.Object是所有类的父类）。 

 

注意：

1、父类的私有成员子类不能继承到;父类的构造方法不能被继承。

2、一个类有且只有一个直接父类;一个类没显示的继承其他的一个类的时候,默认的直接父类就是Object类;一旦一个类显示的继承了其他的一个类的时候,此时默认的直接父类Object就会被取消。

3、Java里一个类只能有一个直接父类;java.lang.Object是所有类的父类，Object要么是直接父类要么是间接父类。

4、子类对象在实例化之前必须首先调用父类中的构造方法之后再调用自身的构造方法。

 

9、子类访问父类和方法覆写

注意： 

1、子类不能直接访问父类的私有成员（但是子类可以调用父类中的非私有方法来间接访问父类的私有成员）。

2、方法覆写产生原因：当父类中某个方法不适合于子类时,子类出现父类一模一样的方法.

调用被覆盖的父类方法：使用super.方法名(实参);

子类方法的返回值类型比父类方法的返回值类型更小或相等

子类方法声明抛出的异常应比父类方法申明抛出的异常更小或相等;

子类方法的访问权限应比父类方法更大或相等;

 

10、super关键字和调用父类构造方法

特点:表示父类对象的默认引用

如果子类要调用父类被覆盖的实例方法，可用super作为调用者调用父类被覆盖的实例方法。

使用super调用父类方法

使用super调用父类的构造方法

调用构造方法

本类中调用另一个重载构造方法用this(参数列表)

子类构造方法调用父类构造方法用super(参数列表)

注意：子类调用父类的构造方法时：super必须放在第一句；

Java在执行子类的构造方法前会先调用父类无参的构造方法，其目的是为了对继承自父类的成员做初始化操作。

子类在创建对象的时候，默认调用父类的无参构造方法，要是子类构造方法中显示指定调用父类其他构造方法，就调用指定的父类构造方法，取消调用父类无参构造方法。

 

示例代码：

class A{      String name;      A(){          System.out.println("父类默认隐式的构造方法！");      }            A(String name){          System.out.println("父类显式的构造方法！");      }  }    class B extends A{            B(){          super(null);          System.out.println("子类默认隐式的构造方法！");      }  }    public class Demo10 {      public static void main(String[] args) {          new B();      }  } <span style="color:#c0c0c0;"> </span>

11、面向对象---多态

概念： 多态指同一个实体同时具有多种形式

编译时的类型由声明该变量时使用的类型决定,运行时的类型由实际赋给变量的对象决定。

如果编译时类型和运行时类型不同，就出现多态。

比如：Student  extends   Person:

Person p = new Person();

Student s = new Student();

Person p = new Student();//多态，引用关系:父类变量指向子类实例对象

 

实现多态的机制:

父类的引用变量可以指向子类的实例对象,而程序调用的方法在运行期才动态绑定，就是引用变量所指向的真正实例对象的方法,也就是内存里正在运行的那个对象的方法，而不是引用变量的类型中定义的方法。 

 

多态的作用：

把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，以适应需求的不断变化。

只修改方法的实现，不必修改方法的声明

继承是多态产生的前提条件;

 

分类:

编译时多态：方法重载

运行时多态：方法覆写

 

示例代码：

1. class Dog{      void eat(){          System.out.println("一般的狗吃一般的狗粮！");      }  }    class HashDog extends Dog{      void eat(){          System.out.println("哈士奇吃哈士奇的狗粮！");      }  }    class ZangAoDog extends Dog{      void eat(){          System.out.println("藏獒吃藏獒的狗粮！");      }  }    //定义一个动物园喂的方法  class Zoo{            void feed(Dog d){          d.eat();      }        }    public class Demo11 {      public static void main(String[] args) {                    Dog hd = new HashDog();                    Dog zd = new ZangAoDog();                    Zoo z = new Zoo();          z.feed(hd);          z.feed(zd);      }  }