1.抽象类
(1)抽象类的概念:
针对一个事物,比如:动物类---->总体概括,之前定义一个具体的动物(---->必须给他的某个功能只是声明即可),只有,猫或者狗等等这些才是具体事物
Java中,如果一个类中有一个方法声明(抽象方法)抽象功能,那么这个类定义为抽象类
针对一个事物,比如:动物类---->总体概括,之前定义一个具体的动物(---->必须给他的某个功能只是声明即可),只有,猫或者狗等等这些才是具体事物
Java中,如果一个类中有一个方法声明(抽象方法)抽象功能,那么这个类定义为抽象类
关键字:
abstract 抽象的意思
(2)抽象类的特点:
抽象类不能直接实例化!(即不能创建对象)
(3)关于抽象类:
1)如果一个类中有抽象方法,那么这个类是一定是一个抽象类
2) 抽象类中不一定都是抽象方法
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() ;// 接口中的方法不能有方法体,只能是抽象方法!
}
interface 接口名{
//抽象功能
public abstract void jump() ;// 接口中的方法不能有方法体,只能是抽象方法!
}
(3)接口的特点:不能实例化
(4)接口的子实现类:实现类 (具体的实现类)
class 类名+impl implements 接口名{
class 类名+impl implements 接口名{
}
接口的子类如果是抽象类:没有意义,不能实例化
(5)创建对象
AniamlTrain at = new JumpCatImpl() ;//接口多态(实际开发中用的最多)
(6)
接口成员的特点:
成员变量: 是一个常量,不能更改,并且默认的修饰符 public static final
构造方法: 接口不存在构造方法
成员方法:都是抽象方法
默认的修饰符:public abstract
成员变量: 是一个常量,不能更改,并且默认的修饰符 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"的关系(扩展功能) :跳高猫 像猫
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 ; } }