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

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

 

 

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

 

 

四、 面向对象之继承

          1.定义

         继承类似子父关系，只有类与类之间有所属的关系，才可以继承。子类具有父类的属性，但是子类中还有自己的属性。
         比如：人作为一个类，所有的人都有name、age、sex属性，工人会盖楼，警察会抓小偷，这是他们各自的技能方法，但是工人，警察都是人，工人和警察继承人这个类，本身就具有了name、age、sex属性了，在各自的类中只用再创建各自特有的方法即可。
          继承就是将一类事物的共性提取出来到一个类中，然后具体的类继承这个类。两个类之间通过extends关键字实现继承

          2.作用

         继承提高了代码的复用性。而且让类与类之间产生了关系，因此有了面向对象的第三个特征：多态。

          3.子父类关系

         首先举例说明一个问题：

class A {
public A() {
System.out.println("A()!");
}
}

class B extends A {
public B() {
System.out.println("B()!");
}
}
public class ExtendsTest extends B {

public ExtendsTest() {
System.out.println("ExtendsTest()!");
}

public static void main(String[] args) {
new ExtendsTest();
}
}

ExtendsTest继承自B，B继承自A，当实例化ExtendsTest的时候，依次打印出了A、B、ExtendsTest构造器中的内容，说明：构造器被依次调用了，这是为什么？因为当类实现继承时，默认的会将基类的一个子对象传给子类，而子类需要对这个子对象进行初始化，所以需要调用父类的构造器，但是，这一切都是隐式进行的，我们看不到，不过可以从实验中得出结论：在对子类进行初始化的时候，会先调用父类的构造器。如果父类构造器需要传递参数，则使用super关键字来实现就行了。

           子类不能继承父类私有的域或者方法。如果想要继承父类的私有对象，只能将private改成protected，因为protected的权限控制在包内。因此一般情况，用到继承的话，最好将父类中的域声明为私有（private，因为一般情况不需要继承成员变量），将方法声明为public，方便继承。
           当子类对象调用一个方法时，如果子类没有，则去调用父类的同名方法，但是调用者保持是子类

         4.关键字：final

          Final可以修饰类、方法、变量。
          被final修饰的类不可以被继承。
          被final修饰的方法不可以被复写
          被final修饰的变量只可以被赋值一次，即常数变量。通常的类中不变的数被final修饰，作为一个常数存在：
        

        public final static long PI=3.1415926;

 

         5.抽象类（abstract）

         当多个类中出现相同的功能，但是主体相同的时候，这时候可以向上抽取共性，定义成一个抽象类。
         抽象类注意的几个点：（1）抽象方法必须放在抽象类中（2）抽象类不能被创建对象（3）在抽象类中定义抽象方法时，方法无方法体，也无{}。（4）抽象类中的方法要被调用，必须由子类复写所有的抽象方法。

<SPAN style="FONT-SIZE: 18px">public class B extends A {


void a() {
System.out.println();
}

}
abstract class A {

abstract void a();
void b(){

}
}

           接口和抽象类这两个概念总是被放在一起讨论，因为他们有很多相似的地方，可以说接口本身就是完全抽象的，它要比抽象类更加“抽象”，为什么这么说？抽象类是一种类，里面除了有抽象方法外，还可以有具体的方法，而接口里面必须都是抽象的方法，尽管有时并没有显示的用abstract关键字声明。此处我们提到抽象方法，在Java中，凡是声明为形如：abstract void function()的方法，都是抽象方法，包含抽象方法的类就是抽象类，可以这么总结：抽象类中是可以没有抽象方法的；有抽象方法的类必须是抽象类；抽象类不一定有实体方法。

          6.接口（interface）

         接口是特殊的抽象类，因为接口中的方法都是抽象的方法。
         接口中的成员都是public的，
         接口特点：类只能继承一个类，但是可以实现多个接口，接口与接口也可以有继承关系。
         之前我们知道，采用interface为我们提供了一种将抽象与实现分离的结构化的方法，但是interface的作用远不止此，在Java中接口解决了一个非常重要的问题：多继承。Java继承机制不允许多重继承，所以如果想要整合不同类的功能，就需要使用接口。举个例子来说明：

<SPAN style="FONT-SIZE: 18px">interface CanFight {void fight();}
interface CanFly {void fly();}
interface CanSwim {void swim();}
class ActionCharacter {public void fight(){}}
class Hero extends ActionCharacter implements CanFight, CanFly, CanSwim {

public void swim() {}


public void fly() {	}

}
public class Adventure {

public static void t(CanFight x){x.fight();}

public static void u(CanSwim x){x.swim();}

public static void v(CanFly x){x.fly();}

public static void w(ActionCharacter x){x.fight();}

public static void main(String[] args) {
Hero h = new Hero();
t(h);
u(h);
v(h);
w(h);
}
}

我们可以看到：
          1、Hero类中拥有了所有类的功能。
          2、Hero可以和它实现的这些接口进行相互转换，当我们将hero对象做参数，传入Adventure类的各个方法时，Hero类向上转型了。总结下使用接口的好处：
           3、接口可以实现向上转型，多个具有共同属性的类可以将它们的共同点提取出来，做成抽象，这样层次分明，统一管理。
           4、接口不具有任何实现，最适合做基类。

总结一下抽象类与接口的区别和联系：
             a)抽象类是类，可以有实体方法。
             b)抽象类不能实现多继承，而接口可以。
             c)如果需要创建不带任何方法定义和成员变量的基类，则使用接口，如果类中需要有部分具体的实现，则使用抽象类。
            d)如果事先想要将某类设计为一个基类，那么首选接口。

五、 多态

          1.定义

         事物存在多种体现形态，比如：男人也是人；小轿车也是车；杂志也是书。
         多态一般使用在子父类的引用中，父类接收子类对象父类 变量名=new 子类（）；//类型进行了提升，类似于隐式的转换。

<SPAN style="FONT-SIZE: 18px">class Test
{
public static void main(String[] args) 
{
Person stu=new Student();
stu.say();
}
}


class Person
{
private String name;
private int age;

}
class Student extends Person
{
public void say()
{
System.out.println("hello");
}
}

           多态的好处：大大的提高了程序的扩展性。
       注意：多态编译的时候，父类中无与子类中相同成员方法名称的成员函数时，对像是不能调用的，运行时，对象调用先运行同名子类成员函数。

          2.内部类

         内部类的意思就是将类的定义放在另一个类的内部。有时合理的内部类使用会使代码更加简洁，令程序更加巧妙。而且作为外部类的成员，内部类可以访问外部类私有的成员变量。

外部类创建内部类对象的格式：

<SPAN style="FONT-SIZE: 18px">public class InnerClass {
class A{
int a = 10;
void b(){
System.out.println("this is A.b()!");
}
}

public static void main(String[] args) {
InnerClass ic = new InnerClass();
InnerClass.A aa = ic.new A();
aa.b();
}
}

           静态内部类不可以引用外部类的非静态成员。
           当内部类成员为静态时，内部类必须为静态的。

          使 用匿名内部类应该注意：
           a)匿名内部类不能有构造方法
           b)匿名内部类不能定义任何静态成员、方法和类。
           c)匿名内部类不能是public,protected,private,static。
           d)只能创建匿名内部类的一个实例。
           e)一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。
           f)因匿名内部类为局部内部类，所以局部内部类的所有限制都对其生效。
         举例说明一下匿名内部类：

  

<SPAN style="FONT-SIZE: 18px">ScheduledExecutorService timer = Executors.newScheduledThreadPool(1);
timer.scheduleAtFixedRate(
new Runnable(){
public void run(){

currentLamp = currentLamp.dark();
}
},
5,
5,
TimeUnit.SECONDS);

 

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