java--面向对象（4）--黑马程序员

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

面向对象（4）

主要内容：《 抽象类、 接口、类名作为形式参数、抽象类名作为形式参数、接口名作为形式参数、类名作为返回值类型、 抽象类名作为返回值类型、接口名作为返回值类型、链式编程 》

1 抽象类的概述及其特点

回顾我们之前的继承：

1.一般不会实例化"父类"的对象；因为"父类"没有对应现实世界中的实体。我们经常使用子类。

2.父类会定义某些方法，而这个方法会被每个子类重写。

class Person{
void show(){
System.out.println("我是传智播客的一员");
}
}
class Student extends Person{
//重写
void show(){
System.out.println("我是传智播客的一名学生，我骄傲！！");
}
class Teacher extends Person{
//重写
void show(){
System.out.println(我是传智播客的一名教师，我骄傲！！");
}

3.基于上述，以及一些其它原因：

1).某些父类既然不会去实例化，那么就干脆将这个类定义为：不可实例化的；这种类就叫：抽象类2).父类中的某些方法，都会被子类重写，那么干脆：父类只提供"方法签名"，不提供"具体实现"。

这种方法就叫：抽象方法；

4.定义抽向，使用关键字：abstract

5.可以修饰：1.类：abstract class 类名{}

说明：此类将不能被实

例化；就是用来做父类的，让子类去继承的；

2.成员方法：abstarct void show();

说明：此方法是个"抽象方法"，用来被子类"重写的"

6.说明： 1.一个"抽象类"中可以没有抽象方法；

2.如果一个类中包含了"抽象方法"，那么这个类必须是"抽象类"；

3.如果一个"子类"继承"抽象类"，仍然使用关键字：extends。而且仍然是"单继承"；

4.如果一个"子类"继承了"抽象类"，那么必须重写全部的"抽象方法"。如果不重写，或不完全重写，

那么这个"子类"也必须是个"抽象类"。

从另一个角度：一个抽象类，可以继承自另一个抽象类；

bstract class Person{
abstract void show();
}
class Student extends Person{
//重写了父类的方法；
void show(){
}
}
class Demo {
public static void main(String[] args) {
System.out.println("Hello World!");
}
}

2 抽象类的说明

抽象类：

1.抽象类中可以没有抽象方法；也可以什么都没有；

2.如果抽象类中包含了抽象方法，那么这个类必须要声明为抽象的；

3.抽象类中可以有什么：

1).成员变量；

2).构造方法，并且可以重载；为成员变量赋值；

3).普通，实现的成员方法：

4).抽象方法；

4.抽象类，跟普通的父类的区别：

1).抽象类不能被实例化；

2).抽象类中可以包含抽象方法；

abstract class Person{
//成员变量
String name;
int age;
char sex;
//构造方法
Person(){
System.out.println("Person的无参构造方法......");
}
Person(String name,int age ,char sex){
this.name = name;
this.age = age;
this.sex = sex;
}
//普通，实现的成员方法
void eat(){
System.out.println("吃饭");
}
void sleep(){
System.out.println("睡觉");
}
//抽象方法
abstract void show();
}
class Student extends Person{
Student(){
System.out.println("Student的无参构造方法");
}
Student(String name,int age,char sex){
/*
this.name = name;
this.age = age;
this.sex = sex;
*/
//显示的调用父类的带参的构造方法
super(name,age,sex);
}
//重写show
void show(){
System.out.println("子类重写的show");
}
}
class Demo {
public static void main(String[] args)
{
Student stu = new Student("张学友",22,'男');
/*
stu.name = "刘德华";
stu.age = 20;
stu.sex = '男';
*/
System.out.println(stu.name + "," + stu.age + "," + stu.sex);
}
}

3 抽象类中的面试题

一.一个类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?

1.可以；

2.只是父类使用。而且这个父类不可以实例化；

二.abstract不能和哪些关键字共存:

1.private:因为一个抽象方法就是被子类重写的。要重写就必须不能为private的。

2.final:因为一个抽象方法就是被子类重写的。而final表示：最终方法，不能被重写。所以这两个关键字冲突；

作用在"类"上也是一样：一个抽象类就是用来被继承的。而final类：表示最终类，不能被继承。所以也是冲突；

3.static:因为一个抽象方法没有方法体。所以不能定义为static的。因为无法被分配空间；

abstract class Person{

//一个抽象类内部，可以什么都不定义

abstract static void show();

}

4 接口的概述及其特点

我们之前定义了两种父类：

1.普通的父类：可以被实例化(虽然我们很少去实例化父类对象)；

2.抽象类：它内部包含了一些抽象方法。不能被实例化；

3.接口： 如果一个抽象类中，没有成员变量，没有实现的方法，只包含了一些"抽象方法"，这时，我们可以将

这个类定义为"接口"：

1.定义接口，使用关键字：interface

2.接口：不能被实例化，用来被子类"实现"的；

3.子类实现接口，使用关键字：implements

4.接口中可以包含(JDK8以前)：

1).成员变量：必须被声明为：public static final。如果不写这几个修饰符，系统会自动添加.

2).抽象方法：必须被声明为：public abstract。如果不写这几个修饰符，系统会自动添加。

5.接口的作用：

1).Java是"单继承"的，不能同时继承多个类。Java的一个类实现接口时，可以同时实现多个接口；所以，在Java中，通过"实现接口"达到"功能扩展的目的

interface Person{
int num = 10;//编译为：public static final int num = 10;
void show();//编译为：public abstract void show();
//    void fun(){};//编译错误，不能包含实现的方法；
}
class Student implements Person{
//重写接口中的抽象方法时，必须要使用：public访问修饰符；
public void show(){
System.out.println("Student的重写的show()");
}
}
class Demo {
public static void main(String[] args) {
Person p = new Student();
p.show();
}
}

5 接口的作用

Java中通过接口实现功能的扩展：

项目经理：

abstract class Service{

abstract void save();//新增

abstract void update();//修改

abstract void delete();//删除

abstract void findById();//用ID查询一条记录；

}

要求，所有项目组的访问数据库的类都必须继承这个类：
"用户管理模块"：
class UserService extends Service implements IFu {
//重写方法
void save(){        }
void update(){        }
void delete(){        }
void findById(){        }
//重写接口中的方法
public void check(){
}
public void log(){
}
}
"车辆管理模块":
class CarService extedns Service implements IFu{
//重写方法
void save(){
}
void update(){
}
void delete(){
}
void findById(){
}
//重写接口中的方法
public void check(){
}
public void log(){
}
}
副项目经理：
abstract class AbstractFu{
abstract void check();//检查权限
abstract void log();//写入日志
}
副项目经理也要求所有模块的访问数据库的类要继承这个类，并实现这两个方法；
//改为接口实现
inteface IFu{
abstract void check();//检查权限
abstract void log();//写入日志
}
class Demo {
public static void main(String[] args)
{
System.out.println("Hello World!");
}
}

6 接口的使用

asd接口的使用：

1.接口的作用就是用来：扩展功能；

2.一个子类，可以同时实现一个，或多个接口；

3.一个子类，可以同时继承自一个类，并且实现一个，或多个接口。 一定要：先继承，后实现接口；

4.一个子类，如果实现一个接口，那么必须全部重写接口中的"抽象方法"，否则，这个子类，也得是一个抽象的。

5.一个接口可以"继承自"另一个或多个接口，也就意味着使用关键字：extends，并且可以多继承

类与类,类与接口,接口与接口的关系

类和类，类和接口，接口和接口之间的关系：

1.类和类：继承：使用关键字：extends ；单继承；

2.类和接口：实现；使用关键字：implements；可以同时实现多个接口

3.接口和接口：继承：使用关键字：extends；可以多继承；

上述中说的类都包含"抽象类"

//*******类和类**********//
class Fu{
}
class Zi extends Fu{
}
//*********类和接口**************//
interface IA{
}
class A implements IA{
}
//*********接口和接口**********//
interface IB{
}
interface IC extends IA,IB{
}
class Demo {
public static void main(String[] args) {
System.out.println("Hello World!");
}
}

7 抽象类和接口的区别

相同点：

1.都不能被实例化。都是做父类的；

区别：

1.成员：

抽象类：成员变量、常量、构造方法、实现的方法、抽象方法；

接口：常量、抽象方法；

2.关系：

抽象类：子类是继承，使用关键字：extends

接口：子类是实现，使用关键字：implements

类和类：是继承，使用extends;

接口和接口：是继承，使用extends;

　　　　　　 类和接口：是实现，使用implements;

3.设计理念：

抽象类：被设计为"is a(是一个)"的关系。

接口：被设计为"like a"的关系。

8 类名作为形式参数

class Student{
String name;
int age;
}
class BasicStudent extends Student{}
class Demo {
public static void main(String[] args) {
//method(Student);//错误，传递的不是Student引用
//method(Student stu);//错误
Student s = new Student();
s.name = "刘德华";
s.age = 20;
//method(Student s);//错误：传递实参时，不需要"类型"
//1.可以传递一个Student对象的引用
method(s);//OK的。正确的；
//2.可以传递一个null值
method(null);
//3.可以传递一个Studend的子类对象的引用。多态
BasicStudent s2 = new BasicStudent();
method(s2);
//使用匿名对象
method(new BasicStudent());
}
//当一个"类名"做为形参时，表示：这个方法可以接收一个这个类型的"对象的引用"；
//可以传递的：1.Student对象的引用(正常情况)；2.可以传递一个null值；3.Student的子类对象引用(多态)
public static void method(Student stu){//Student stu = null;
if(stu != null){
System.out.println(stu.name + "," + stu.age);
}}}

9 抽象类名作为形式参数

abstract class Person{
String name;
int age;
}
class Student extends Person{
}
class Demo {
public static void main(String[] args) {
//    Person per = new Person();//不可以。Person是抽象的，不能实例化
Student stu = new Student();//实例化一个Person的子类；
stu.name = "章子怡";
stu.age = 18;
method(stu);//将子类对象的引用作为实参，传递进去；
}
//使用"抽象类"作为方法的形参：意味着，可以接收一个它的"子类对象的引用"(多态)；
public static void method(Person p){//Person p = new Student();
System.out.println(p.name + "," + p.age);
}
}

10 接口名作为形式参数

interface English{
void speakEnglish();
}
class Student implements English{
//重写方法
public void speakEnglish(){
System.out.println("我是学生，我说英语......");
}
}
class Player implements English{
//重写方法
public void speakEnglish(){
System.out.println("我是运动员，我说英语......");
}
}
class Coach{
public void speakEnglish(){
System.out.println("我是教练，我说英语......");
}
}
class Demo {
public static void main(String[] args) {
Student stu = new Student();
method(stu);
Player p = new Player();
method(p);
//由于Coach没有实现English接口，所以它不是English类型的。不能作为实参传递
Coach c = new Coach();
//    method(c);
}
//使用接口作为方法的形参；意味着：这个方法可以接收：这个接口的子类对象的引用；
public static void method(English en){
en.speakEnglish();
}
}

11 类名作为返回值类型

class Student{
String name;
}
class BasicStudent extends Student{
}
class WorkStudent extends Student{
}
class Demo {
public static void main(String[] args) {
Student s = method();//接收返回值//Student s = 0x2233
if(s != null){//如果调用的方法返回的是一个"引用类型"，在使用前，最好先进行判断；
System.out.println("name = " + s.name);
}
/由于方法返回的是"Student"类型，它可能返回Student对象的引用，也可能返回任何Student子类的对象的引用
//所以，由于不确定是哪个子类，所以不能用某个具体的子类变量接收，只能用Student来接收；
//此规则，同样可以应用于"抽象类"和"接口"作为方法返回值的情况。
//BasicStudent bs = method();//编译错误，不能用具体的子类类型来接收；
}
//一个方法的返回值类型声明为一个类类型，意味着：
//1.这个方法必须返回一个此类对象的一个引用(常见)；2.可以返回一个null；3.可以返回Student的子类对象的引用
public static Student method(){
//return Student;//错误，需要返回一个引用
//1.可以返回一个Student对象的引用
/*
Student stu = new Student();//stu = 0x2233;
stu.name = "刘德华";
return stu;//OK的
*/
//2.可以返回null
//    return null;//OK的//return 0x2233
//3.可以返回一个子类引用
Student basicStu = new BasicStudent();
basicStu.name = "章子怡";
return basicStu;
}
}

12 抽象类名作为返回值类型

abstract class Animal{
String name;
}
class Cat extends Animal{
}
class Dog extends Animal{
}
class Demo {
public static void main(String[] args) {
//由于不确定是某个具体的子类类型，所以，不能用子类类型来接收。
//    Cat c = get();
Animal a = get();
if(a != null){
System.out.println("main方法打印：" + a);
}
}
//方法的返回值类型为"抽象类"类型。意味着：
//1.这个方法会返回这个抽象类的子类对象的引用；
//2.null;
public static Animal get(){
//    return Animal;//错误的
//    return new Animal();//错误的：抽象类不能被实例化
Cat c = new Cat();
c.name = "波斯猫";
return c;
}
}

13 接口名作为返回值类型

interface IAnimal{
void show();
}
class Cat implements IAnimal{
//重写方法
public void show(){
System.out.println("小猫喵喵......");
}
}
class Dog implements IAnimal{
//重写方法
public void show(){
System.out.println("小狗汪汪......");
}
}
class Demo {
public static void main(String[] args) {
IAnimal a = get();
if(a != null){
a.show();
}
}
//一个方法的返回值类型为：接口类型。意味着：
//1.此方法会返回此接口的子类对象的引用；
//2.null;
public static IAnimal get(){
//    return IAnimal;//错误
//    return new IAnimal();//错误
//    return new Cat();//OK的
return new Dog();//OK的
//    return null;//OK的
}
}

14 链式编程

interface IA{
public int max(int a ,int b);
}s
class Student{
String name;
int age;
Student(){
}
Student(String name,int age){
this.name = name;
this.age = age;
}
void show(){
System.out.println("我叫：" + this.name + " 今年：" + this.age + "岁");
}
}
class StudentTools{
void print(Student stu){
if(stu != null){
System.out.println(stu.name + "," + stu.age);
}
}
Student getStudent(){
Student stu = new Student("汪峰",23);
return stu;
}
}
class Demo {
public static void main(String[] args) {
/*
StudentTools st = new StudentTools();
Student stu = new Student();
stu.name = "章子怡";
stu.age = 18;
st.print(stu);
*/
new StudentTools().print(new Student("张惠妹",20));
//    new StudentTools().getStudent().show();
//分步骤写
StudentTools st = new StudentTools();
Student stu = st.getStudent();
stu.show();
//使用链式编程
new StudentTools().getStudent().show();
//    System.out.println("aaa");
}

public static void print(){
}
}