黑马程度员--------------面向对象（二）

一，封装

是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。之所以对外提供访问方式，就是因为可以在访问方式中加入逻辑判断等语句，可对访问的数据进行操作提高代码的健壮性。

好处：提高重用性，安全性。

封装原则：将不需要对外提供的内容都隐藏起来，把属性都隐藏，提供公共方法对其访问。如定义人的对象，将人的姓名和年龄进行隐藏，再通过定义方法让外部可以对其进行设置和访问。

Class Person

{

   Private String name;

   Private int age;

   Person(String name,int age)

{

    This.name=name;

    This.age=age;

}

Public voidsetName(String name)

{

   This.name=name;

}

Public StringgetName()

{

    Return name;

}

Public voidsetAge(int age)

{

This.age=age;

}

Public int getAge()

{

   Return age;

}

}

This:用于区分局部变量和成员变量同名的情况。代表它所在函数所属对象的引用，也就是说哪个对象在调用this所在的函数，this代表的是哪个对象。

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

This语句：用于构造函数之间进行互相调用，this语句只能定义在构造函数的第一行，因为初始化要先执行。

Static关键字：是一个修饰符，可以修饰成员（成员变量，成员函数）。

 特点：1，想要实现对象中的共性数据的共享，可以将这个数据进行静态修饰。

       2，被静态修饰的成员，可以直接被类名所调用。类名.静态成员。

3，被静态所修饰的成员是随着类的加载而加载，而且优先于对象存在。

静态的弊端：1，静态方法只能访问静态成员。

             2，静态方法中不可以定义this,super关键字，因为静态优先于对象存在，所以静态方法中不可以出现this关键字。

           3，生命周期过长。

二，继承

特点：1，提高了代码的复用性。

      2，让类与类之间产生了关系，有了这个关系才有了多态的特性。只支持单继承，但可以多实现，还可支持多层继承。这是因为如果多继承的话，容易出现安全隐患，如果两个父类中出现了同名的函数时，在调用子类的方法时不知道要执行的是哪个函数。

Class a

{}

Class b extendsa

{}

Class c extendsb

{}

这样，C中就具备了A和B中的所有方法。

子父类出现后，类中的成员有了哪些特点：

1， 成员变量

 当子父类中出现了同名的成员变量时，当调用子类对象时执行的是子类对象中的变量。

 如果想要调用父类中的成员变量时，需要使用super关键字。Super代表的是子类对象引用父类变量。

2， 成员函数

当子类中出现了和父类一模一样的函数时，当子类对象调用该函数时，会运行子类函数的内容，如果同父类的函数被覆盖一样，这就叫覆盖。

        Class a

{

   Void run()

{

  System.out.println(“a is run”);

}

}

Class b extends a

{

   Void run()

{ System.out.println(“b is run”);}

}

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

2， 静态只能覆盖静态

抽象类

  当描述一个类时，发现该类具备一个方法，但是每个子类具备该方法时，方法主体都不一样，这时就需要用abstract关键字来修饰该类。

Abstract的特点：

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

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

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

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

Abstract class a

{

   Abstractvoid show1();

   Abstractvoid show2();

}

Abstract Class b extends a

{

  Publicvoid show1(){}

   Publicvoid show3(){}

}

以上例子中，子类只覆盖了show1的方法，而show2的方法并没有覆盖，所以子类还是一个抽象方法。

关键字abstract不可以和final,static,private 一起用。

接口

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

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

   常量：public static final

   方法：public abstract

   接口中的成员都是public 所修饰的。

3， 接口与接口之间可以多继承，是因为接口中的方法都是抽象的，当两个父类接口中有同名方法时，子接口在复写后不会出现冲突。

4， 接口是对外提供的规则，提高了功能的扩展，并且降低了藕合性。

三，多态

某一事物具有不同的表现形式。如猫可以叫作动物，也可以叫猫。

多态的好处：提高了程序的扩展性。

多态的弊端：当父类的引用指向了子类对象时，虽然提高了扩展性，但是只能访问父类中具备的方法，不可以访问子类特有的方法。

多态的前提：必须是类与类之前有关系，要么是继承要么是实现，通常还有一个前提：存在覆盖。

Animal a=newCat();这个是类型提升（向上转型），将猫提升为动物。

如果想要调用猫的特有方法时，需将父类的引用转成子类类型。也叫向下转型。

Cat c=(Cat)a;这个是将已经提升为动物的猫再向下变为猫，这时就可以调用猫特有的方法。

在多态中成员函数的特点（非静态）:

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

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

简单一句话：成员函数在多态调用时，编译看左边，运行看右边。

Class Fu

{

int num=5;

  Void show()

{

   System.out.println(“fu run”);

}

public static void show3()

{System.out.println("fu-----show3");}

}

Class zi extendsFu

{

int num=8;

   Void show2()

{

   System.out.println(“zi run”);

}

public static void show3()

{System.out.println("zi-----show3");}

}

Class Demo

{

  Public static void main(String[] args)

{

   Fu f=new Zi();

   f.show();

   System.out.println(f.num);-->5

  f.show3();---->执行的是父类中的show3方法。

}

}

在多态中，成员变量的特点：无论编译还是运行，都看左边（引用型变量所属的类）

在多态中，静态成员函数的特点：无论编译还是运行，都看左边