1.抽象类
(1)抽象类的概念:
针对一个事物,比如:动物类---->总体概括,之前定义一个具体的动物(---->必须给他的某个功能只是声明即可),只有,猫或者狗等等这些才是具体事物
Java中,如果一个类中有一个方法声明(抽象方法)抽象功能,那么这个类定义为抽象类
关键字:abstract 抽象的意思
(2)抽象类的特点:抽象类不能直接实例化!(即不能创建对象)
(3)关于抽象类:
1)如果一个类中有抽象方法,那么这个类是一定是一个抽象类
2) 抽象类中不一定都是抽象方法
(4)抽象类的子类
1)如果子类是抽象类,没有意义,因为都不能实例化,对象如何创建
2)子类具体类,那么子类必须实现父类中的抽象功能.
(5)抽象类的成员特点:
成员变量: 可以是变量,也可以是一个常量
构造方法: 可以有无参,可以有有参,作用:给对象进行初始化的.
成员方法: 可以有抽象方法,还可以有非抽象方法
比如:
//定义一个抽象的人类
abstract class Person{
private String name ;
int num = 10 ; //变量
public final int num2 = 100 ;//常量
//无参构造
public Person() {}
//有参构造
public Person(String name) {
this.name = name ;
}
//非抽象的功能
public void show() {
System.out.println(num);
System.out.println(num2);
}
//抽象功能
public abstract void method();
}
(6)abstract和哪些关键字是冲突的(不能共有!)?
abstract 和private, abstract 和final, abstract和static
(7)猫狗案例抽象版
/**
* 猫狗案例
具体事物:猫,狗
共性:姓名,年龄,吃饭
分析:具体到抽象
代码实现:从抽象到具体
分析:
猫 Cat
成员变量:name,age
构造方法:无参/有参
成员方法:setXXX/getXXX() eat
狗 Dog
成员变量:name,age
构造方法:无参/有参
成员方法:setXXX/getXXX() eat
抽象的Animal类 :父类 eat() ;
* @author Administrator
*
*/
//抽象的动物类
public abstract class Animal {
private String name ;
private int age ;
public Animal() {
super();
}
public Animal(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
//抽象功能
public abstract void eat() ;
}
//猫类
public class Cat extends Animal {
public Cat() {
super();
}
public Cat(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println("猫吃鱼...");
}
//自己的功能
public void playGame() {
System.out.println("会玩毛线...");
}
}
//狗类
public class Dog extends Animal {
public Dog() {
super();
}
public Dog(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println("狗吃骨头...");
}
public void lookDoor() {
System.out.println("会看门...");
}
}
//测试类
public class AnimalDemo {
public static void main(String[] args) {
//测试猫类
//方式1:无参/set
Animal a = new Cat() ; //抽象类多态
a.setName("TOM");
a.setAge(5);
System.out.println("猫的姓名是:"+a.getName()+",年龄是:"+a.getAge());
a.eat();
//a.playGame() ;错误,多态的弊端就是父类不能访问子类特有功能!
//要么向下转型,要么具体类创建具体类
Cat c = (Cat)a;
c.playGame();
System.out.println("------------------------");
//方式2:带参构造创建对象 (具体类创建具体类对象)
Cat c2 = new Cat("TOM", 3) ;
System.out.println("猫的姓名是:"+c2.getName()+",年龄是:"+c2.getAge());
c2.playGame();
c2.eat();
}
}
2.接口
(1)接口:体现的是事物的扩展性功能(额外动作,后天经过学习等等)
(2)接口格式(接口:见名知意)
interface 接口名{
//抽象功能
public abstract void jump() ;//接口中的方法不能有方法体,只能是抽象方法!
}
(3)接口的特点:不能实例化
(4)接口的子实现类:实现类 (具体的实现类)
class 类名+impl implements 接口名{
}
接口的子类如果是抽象类:没有意义,不能实例化
(5)创建对象
AniamlTrain at = new JumpCatImpl() ;//接口多态(实际开发中用的最多)
(6) 接口成员的特点:
成员变量: 是一个常量,不能更改,并且默认的修饰符 public static final
构造方法: 接口不存在构造方法
成员方法:都是抽象方法
默认的修饰符:public abstract
(7)(面试题)接口和抽象类的区别:
A) 成员的区别
成员变量:
抽象类:既可以常量,也可以是变量
接口:只能是常量,默认的修饰符:public static final
构造方法:
抽象类:有构造方法,无参/有参 (给对象进行初始化的)
接口:没有构造方法
成员方法:
抽象类:可以有抽象方法,也可以有非抽象方法
接口:只能是抽象方法 :默认的修饰符:public abstract
B)类与类/类与接口关系的区别
类与类之间的关系:
继承关系,只支持单继承,不支持多继承,但是可以多层继承
类与接口的关系:
实现关系,一个类继承另一个类的同时,还可以实现多个接口...
接口与接口的关系:
是一种继承关系,既可以单继承,也可以多继承...
接口1 extends 接口2,接口3...
C)设计原则的 区别
1)抽象类: 是有继承关系---->体现的是一种"is a"的关系 (A是B的一种或者B是A的一种)
2)接口:类和接口:实现关系--->体现的是一种" like a"的关系(扩展功能) :跳高猫 像猫
(8)猫狗案例接口版
/**
* 猫狗案例,加入跳高的额外功能
分析:具体到抽象
实现:抽象到具体
猫
姓名 .年龄
无参/有参
setXXX
eat(){}
sleep(){}
playGame(){}
狗
姓名 .年龄
无参/有参
setXXX
eat(){}
sleep(){}
lookDoor(){}
Aniaml类 :abstract
姓名 .年龄
无参/有参
setXXX/GetXXX()
eat() ;
sleep();
最抽象:接口:里面跳高的功能
跳高猫 继承 猫 实现 跳高的接口...
* @author Administrator
*
*/
/**
* 这是一个跳高的接口
* @author Administrator
*
*/
public interface Jump {
//提供一个抽象功能
public abstract void jump() ;
}
//抽象的动物类
public abstract class Animal {
private String name ;
private int age ;
public Animal() {
super();
}
public Animal(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
//吃
public abstract void eat();
//睡
public abstract void sleep() ;
}
//猫类
public class Cat extends Animal {
public Cat() {
super();
}
public Cat(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println("猫吃鱼....");
}
@Override
public void sleep() {
System.out.println("猫趴着睡觉....");
}
public void playGame() {
System.out.println("猫玩游戏...");
}
}
//狗类
public class Dog extends Animal {
public Dog() {
super();
}
public Dog(String name, int age) {
super(name, age);
}
@Override
public void eat() {
System.out.println("狗吃猫...");
}
@Override
public void sleep() {
System.out.println("狗躺着睡觉...");
}
public void lookDoor() {
System.out.println("狗躺着睡觉...");
}
}
//跳高猫
public class JumpCat extends Cat implements Jump {
public JumpCat() {
super();
}
public JumpCat(String name, int age) {
super(name, age);
}
@Override
public void jump() {
System.out.println("猫可以跳高了...");
}
}
//跳高狗
public class JumpDog extends Dog implements Jump {
public JumpDog() {
super();
}
public JumpDog(String name, int age) {
super(name, age);
}
@Override
public void jump() {
System.out.println("狗可以跳高了...");
}
}
//测试类
public class AnimalTest {
public static void main(String[] args) {
//可以使用功能最多的类
//创建具体类对象
JumpCat jc = new JumpCat("tom", 5) ;
System.out.println(jc.getName()+"---"+jc.getAge());
jc.eat();
jc.sleep();
jc.playGame();
jc.jump();
System.out.println("------------------");
//狗类自己测试
}
}
3.形式参数和返回值的问题(一定要掌握!)
(1)形式参数问题
形式参数是基本类型,对实际参数没有影响
形式参数是引用类型:类(普通类),抽象类,接口
1)形式参数是一个类(具体类)
class Student{
public void study() {
System.out.println("Good Good Study,Day Day Up...");
}
}
class StudentDemo{
//成员方法
public void method(Student s) {
s.study();
}
}
如何调用StudentDemo中的mehtod()方法?
public static void main(String[] args) {
//在StudentDemo类中,method方法的形式参数是一个Student类(具体类)
//如何调用StudentDemo中的mehtod()方法
//1)创建StudentDemo对象
StudentDemo sd = new StudentDemo() ;
//2)需要创建Student的对象
sd.method(new Student());
System.out.println("----------------");
//链式编程
//匿名对象是可以作为参数传递的
new StudentDemo().method(new Student());
}
2)形式参数是一个抽象类
形式参数是一个抽象类:此时这块需要的是该抽象类的子类对象 (抽象类多态...)
//抽象的Person类
abstract class Person{
public void teach() {
System.out.println("今天天气不错,适合踢球...");
}
}
class PersonDemo{
public void method(Person p) { //不能直接创建对象 Person p =new Person(); 可以采用抽象类多态的形式实现
p.teach();
}
}
如何调用PersonDemo类中的method()方法?
//首先需要提供Pereson类的子类
class Teacher extends Person{
}
//测试类
public class TeacherTest {
public static void main(String[] args) {
//需求:需要调用PersonDemo类中的method()方法
//1)创建PersonDemo对象
PersonDemo pd = new PersonDemo() ;
//Perosn p = new Person() ; //错误的,抽象类是不能实例化的
//2)可以通过子类进行实例化
Person p = new Teacher();
pd.method(p);
}
}
3)形式参数是一个接口
//定义一个接口
interface Inter{
public abstract void study() ;
}
class InterDemo{
public void show(Inter i) { //需要创建该接口对象,不能直接实例化 Inter i = new Inter() ;错误的
//需要提供接口的子实现类,可以通过子实现类进行实例化:接口多态...
i.study();
}
}
如何调用InterDemo这个类中的show()方法?
//首先提供接口的子实现类
class Student2 implements Inter{
@Override
public void study() {
System.out.println("Good Good Study ,Day Day Up ...");
}
}
//测试类
public class StudentTest {
public static void main(String[] args) {
//需求:需要调用InterDemo这个类中的show()方法,如何调用
//创建InterDemo类的对象
InterDemo id = new InterDemo() ;
//接口多态的形式创建Inter对象
Inter i = new Student2() ;
id.show(i);
}
}
(2)返回值问题
如果返回值基本类型:用对应的基本类型去接收数据即可!
如果返回值引用类型:
类(具体类): 需要的是该类的对象
抽象类:那么返回需要的结果是需要当前抽象类的子类对象 抽象类多态
接口:返回需要的结果是当前接口的子实现类对象 接口多态
1)返回值是一个类
class Student3{
public void study() {
System.out.println("Good Good Study ,Day Day Up ...");
}
}
class StudentDemo3{
public Student3 method() {
//需要提供一个该具体类的对象,是一个具体类的情况
//方式1:匿名对象的方式
//return new Student3();
//方式2:具体类创建对象
Student3 s = new Student3();
return s ;
}
}
2)返回值是一个抽象类
//抽象类:那么返回需要的结果是需要当前抽象类的子类对象 抽象类多态
abstract class Person2{
public void show() {
System.out.println("今天天气不错");
}
}
//提供该抽象类的子类
class Teacher2 extends Person2{
}
class PersonDemo2{
public Person2 method() {
//返回值是一个抽象类
//return new Person2() ; 抽象类不能实例化 ,需要提供该抽象类的子类
//方式1:抽象类多态的形式创建对象
//Person2 p = new Teacher2() ;
//return p ;
//方式2:匿名对象,还是通过子类实例化
return new Teacher2() ;
}
}
3)返回值是一个接口
//接口:返回需要的结果是需要当前接口的子实现类对象 接口多态
interface Inter2{
public abstract void study();
}
//提供接口的子实现类
class InterImpl implements Inter2{
@Override
public void study() {
System.out.println("好好学习,天天向上...");
}
}
class InterDemo2{
public static Inter2 method() {
//return new Inter2(); 接口不能实例化,提供接口的子实现类
//return new InterImpl() ; //匿名对象的方式
Inter2 i = new InterImpl();
return i ;
}
}