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

                                      -----------android培训、java培训、java学习型技术博客、期待与您交流！------------

          在此，分享一下自己学习JAVA的学习心得。有不对的地方请帮忙改正，也希望对想学java的同学有帮助！

JAVA语言-面向对象

面向对象（继承）

继承概述：
1）多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需在定义这些属性和行为，只要继承单独的那个类即可。
2）多个类可以称为子类，单独这个类称为父类或者超类。
3）子类可以直接访问父类中的非私有的属性和行为。
4）通过extends关键字让类与类之间产生继承关系。
     class  SubDemo extends Demo{ }
5)继承的出现提高了代码的复用性。
6）继承的出现让类与类之间产生了关系，提供了多态的前提。

继承的特点：
1）Java只支持但继承，不支持多继承。
2）Java支持多层继承（继承体系）
3)定义继承需要注意：不要仅为了获取其他类中的某个功能而去继承；类与类之间要有所属（“is a”）关系。XX1是XX2的一种。
     
super关键字：
1）super和this的用法相同。
2）this代表本类应用。
3）super代表父类应用。
5）当子类出现同名成员时，可以用super进行区分。
6）子类要调用父类构造函数时，可以使用super语句。

函数覆盖（Override）：
1）子类中出现与父类一模一样的方法时，会出现覆盖操作，也称为重 写或者复写。
2）父类中的私有方法不可以被覆盖。
3）在子类覆盖方法中，继续使用被覆盖的方法可以通过super.函数名获取。

覆盖注意事项：

1）覆盖时，子类方法权限一定要大于等于父类方法权限

2）静态只能覆盖静态。

覆盖的应用：

当子类需要父类的功能，而功能主体子类有自己特有内容时，可以复写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。

子类的实例化过程：

1）子类中所有的构造函数默认都会访问父类中空参数的 构造函数。
2）因为每一个构造函数的第一行都有一条默认的语句 super()。
3）子类会具备父类中的数据，所以要先明确父类是如何 对这些数据初始化的。
4）当父类中没有空参数的构造函数时，子类的构造函数 必须通过this或者super语句指定要访问的构造函数。

Java练习代码：

class Tel
{
void show()//父类show
{
System.out.println("number");

}
}
class NewTel extends Tel //通过extends关键字，产生继承关系
{
void show()//子类show
{
super.show();//super表示父类应用
System.out.println("picture");
System.out.println("name");
}
}

class TelDemo
{
public static void main(String[] args)
{
NewTel t = new NewTel();//实例化对象
t.show();//调用show方法
}
}

final关键字：

1）final可以修饰类，方法，变量。    
2）final修饰的类不可以被继承。
3）inal修饰的方法不可以被覆盖。
4）final修饰的变量是一个常量。只能被赋值一次。既可以修饰成员变量，又可以修饰局部变量。
     (修饰变量)final  double PI = 3.14;
5）内部类只能访问被final修饰的局部变量。

抽象类概述：

抽象类的定义：抽象就是从多个事物中将共性的，本质的内容抽取出来。

抽象类：Java中可以定义没有方法体的方法，该方法的具体实现由子类完成，该方法称为抽象方法，包含抽象方法的类就是抽象类。

抽象方法的由来：多个对象都具备相同的功能，但是功能具体内容有所不同，那么在抽取过程中，只抽取了功能定义，并未抽取功能主体，那么只有功 能声明，没有功能主体的方法称为抽象方法。

抽象类的特点：

1）抽象类和抽象方法必须用abstract关键字来修饰。
2）抽象方法只有方法声明，没有方法体，定义在抽象类中。
3）抽象类不可以被实例化，也就是不可以用new创建对象。
4）抽象类通过其子类实例化，而子类需要覆盖掉抽象类中所有的抽象 方法后才可以创建对象，否则该子类也是抽象类。

Java练习代码：

abstract class Student  //学生抽象类
{
abstract void study();
}

class BaseStudent extends Student   //基础学生
{
void study()
{
System.out.println("base study");
}
}
class AdvStudent extends Student  //就业学生
{
void study()
{
System.out.println("adv study");
}
}
class  AbstractDemo
{
public static void main(String[] args) //main函数
{
new BaseStudent().study();
}
}

抽象类相关问题：

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

答：抽象类中的构造方法用于子类实例化使用。

2）抽象关键字abstract不可以和哪些关键字共存？

 答：1).private :因为一个abstract方法需要被重写，所以不能修饰为private;
     2).final:因为一个abstract方法需要被重写。被final修饰的方法是不能被重写的，所以不能同final共存；
     3).static:因为一个abstract方法没有方法体。静态方法需要对方法体执行内容分配空间，所以不能同static共存；

3）抽象类中可不可以没有抽象方法？

答：抽象类不能被实例化，用abstract修饰，可以有抽象方法，也可以没有抽象方法，但是有抽象方法的类一定是抽象类。

模板方法：

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

Java练习代码：

<span style="font-size:18px;">/*
需求：获取程序运行时间；

获取系统时间：System.currentTimeMillis();
*/
abstract class GetTime
{
public final void getTime()//final关键字：强制避免子类重写该函数。
{
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 =1; x<=1000; x++)
{
System.out.print(x);
}
System.out.println("运行结束");
}
}
class TemplateDemo
{
public static void main(String[] args) //main函数
{
subTime gt = new subTime();
gt.getTime();
}
}</span>

未完待续。。。。。

接口：

格式：interface { }

接口中的成员修饰符是固定的。

 1) 成员常量：public static final

  2)成员函数：public abstract

接口的出现将“多继承”通过另一种形式体现出来，即“多实现”。

接口的特点:

1)接口是对外暴露的规则。

2)接口是程序的功能扩展。

3)接口可以用来多实现。

4)类与接口之间是实现关系，而且类可以 继承一个类的同时实现多个接口。

5)接口与接口之间可以有继承关系。

Java练习代码：

<span style="font-size:18px;">abstract class Sporter//抽象类
{
abstract void play();//抽象方法
}

interface Study//接口
{
abstract void study();//抽象方法
}
class zhangsan extends Sporter implements Study//继承Sporter类，并实现了study方法
{
public  void play()//重写play
{
System.out.println("play football");
}
public  void study()//重写study
{
System.out.println("study Java");
}

}
class  InterfaceDemo
{
public static void main(String[] args) //main函数
{
zhangsan zs = new zhangsan();
zs.play();
zs.study();
}
}
</span>

面向对象（多态）

定义：某一类事物的多种存在形态。

例子：动物中猫，狗；

           猫这个对象对应的类型是猫类型 ；
           猫x =  new 猫();
           同事猫也是动物中的一种，也可以把猫称为动物。
           动物  y =  new 猫();
           动物是猫和狗具体事物中抽取来的父类型。
           父类型引用指向了子类对象。

多态的体现：父类的引用指向了自己的子类对象；父类的引用也可以接收自己的子类对象。

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

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

多态的弊处：提高了扩展性，但是只能使用父类的引用访问父类中的成员。

多态的特点：编译时：参阅引用型变量所属的类中是否有调用方法。如果有，编译通过，没有编译失败；

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

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

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

在多态中，静态成员函数在多态调用时，无论编译和运行，都参考左边。    
         
Java练习代码：

<span style="font-size:18px;">class Fu//父类
{
void method_1()
{
System.out.println("fu method_1");
}
void method_2()
{
System.out.println("fu method_2");
}
}

class Zi extends Fu//子类继承父类，并重写了其方法
{
void method_1()
{
System.out.println("Zi method_1");
}
void method_3()
{
System.out.println("Zi method_3");
}
}

class DuotaiDemo2
{
public static void main(String[] args)
{
Fu f = new Zi();//多态
f.method_1();//结果：Zi method_1。Zi类中有该方法，运行时执行Zi类中对象。
f.method_2();//结果：Fu method_2.
//f.method_3();//Zi类中没有该方法编译不通过，

}
}
</span>

Java练习代码：

<span style="font-size:18px;">abstract class Animal//定义一个Animal类
{
public abstract void eat();
}

class Cat extends Animal//cat类继承Animal类
{
public void eat()//重写了Animal类的eat方法
{
System.out.println("吃鱼");
}

public void catchMouse()//cat类的方法
{
System.out.println("抓老鼠");
}
}
class Dog extends Animal</span><span style="font-size: 18px; font-family: Arial, Helvetica, sans-serif;">//Dog类继承Animal类</span><span style="font-size:18px;">

{
public void eat()//重写了Animal的eat方法
{
System.out.println("吃骨头");
}

public void kanJia()//自己的方法
{
System.out.println("看家");
}
}
class  duoTaiDemo
{
public static void main(String[] args)
{
//Animal a = new Cat();//类型提升，向上转型。
//a.eat();
funcation(new Cat());

funcation(new Dog());

}
public static void funcation(Animal a)
{
a.eat();
if (a instanceof Cat) //instanceof:用来在运行时指出对象是否是特定类的一个实例。instanceof通过返回一个布尔值来指出，这个对象是否是这个特定类或者是它的子类的一个实例。
{
Cat c= (Cat) a;//调用猫的特有方法时，强制将父类的引用，转成子类类型，向下转型。
c.catchMouse();
}else if (a instanceof Dog)
{
Dog d= (Dog) a;//调用猫的特有方法时，强制将父类的引用，转成子类类型，向下转型。
d.kanJia();
}

}
}
</span>

内部类

定义：将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类，嵌套类）。

访问特点：
1）内部类可以直接访问外部类中的成员，包括私有成员。
2）而外部类要访问内部类中的成员必须要建立内部类的对象。

访问格式：

1、当内部类定义在外部类的成员位置上，而且是非私有，可以在外部其他类中

可以直接建立内部对象。

    外部类名.内部类名 变量名 = 外部类对象.内部类对象;
Outer.Inner  in = new Outer().new Inner();

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

   比如，private ：将内部类在外部类中进行封装。

         static：内部类具备static的特性。
当内部类被static修饰后，只能直接访问外部类中的static成员。
在外部其他类中，如何直接访问static内部类的非静态成员呢？
new Outer.Inner().method();
在外部其他类中，如何直接访问static内部类的静态成员？
Outer.Inner.method();
注意：当内部类中定义了静态成员，该内部类必须是static。

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

Java练习代码：

<span style="font-size:18px;">class Outer//定义一个外部类
{
static int num = 4;
static class Inner //定义一个内部类
{
//int n = 6;
void method()
{
System.out.println("Inner="+num);
}
}

}
class  InnerclassDemo
{
public static void main(String[] args)
{
//Outer.Inner in = new Outer().new Inner();
//in.method();
new Outer.Inner().method();//当内部类被static修饰后，只能直接访问外部类中的static成员。
//Outer.Inner.method();
}
}
</span>

内部类的位置：

1)内部类定义在成员位置上:可以被private static成员修饰符修饰。被static修饰的内部类只能访问外部类中的静态成员。
2)内部类定义在局部位置上:也可以直接访问外部类中的成员。同时可以访问所在局部中的局部变量，但必须是被final修饰的。

Java练习代码：

<span style="font-size:18px;">class Outer
{
int x = 3;

void method(final int a)
{
//内部类定义在局部时：1、可以直接访问外部类中的成员，但是不可以访问它所在的局部，只能访问被final修饰的变量。
int y = 4;
class Inner//2、局部内部类不能被private和static修饰
{
void function()
{
System.out.println(a);//要想访问y，需定义为final int y = 4；
}
}
new Inner().function();
}
}
class  InnerclassDemo2
{
public static void main(String[] args)
{
Outer out = new Outer();
out.method(7);//进栈后赋给a后，释放。
out.method(8);//进栈后赋给a后，释放。
}
}</span>

匿名内部类：

 定义：就是内部类的简化写法。

 前提：内部类可以继承或实现一个外部类或者接口。

 格式为：new 外部类名或者接口名(){
            
  覆盖类或者接口中的代码，

                (也可以自定义内容。)

}

简单的理解：就是建立一个建立一个带内容的外部类或者接口的子类匿名对象。

Java练习代码：

<span style="font-size:18px;">abstract class absDemo
{
abstract void show();//抽象方法show
}
class Outer
{
int x = 3;
/*
class Inner extends absDemo//内部类
{
void show()
{
System.out.println("show:"+x);
}
}
*/
public void function()
{
//absDemo a =new Inner();
//new Inner().show();
//匿名内部类
absDemo a = new absDemo()
{
void show()
{
System.out.println("show="+x);
}
void haha()
{
System.out.println("haha");
}</span>