1、多态是什么，多态的前提条件是什么?
多态:
事物存在的多种形态
前提:
要有继承
要有方法重写
要有父类引用指向
2、多态中成员访问的特点分别是什么?
成员变量:编译看左边,运行看左边
成员方法(非静态方法):编译看左边,运行看右边
静态方法:编译看左边,运行看左边
3、多态的好处和弊端分别是什么？
好处:
提高代码的安全性
提高代码的维护性
弊端:
不能使用子类的特有属性和行为
4、什么是向上转型，什么是向下转型？
向上转型:
父类引用指向子类对象,把子类对象提升为父类
向下转型:
把已经转成父类的对象,在转换成子类
5、什么是抽象类，它的特点是什么？
抽象类:
抽象就是看不懂的
特点:
抽象类和抽象方法必须用abstract关键字修饰
抽象类不一定有抽象方法,有抽象方法的类一定是抽象类或是接口
抽象类不能实例化那么,按照多态的方式,有具体的子类实例化.其实这也是多态的一种,抽象类多态
抽象类的子类
要么是抽象
要么重写抽象类中的所有抽象方法
6、抽象类的成员特点有哪些?
特点:
成员变量:既可以是变量,也可以是常量.abstract是否可以修饰成员变量.
构造方法:有构造方法
用于子类访问父类数据初始化
成员方法:既可以是抽象,也可以是非抽象的
7、抽象类的面试题：
A、一个类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?
B、abstract不能和哪些关键字共存，为什么？
A:
可以
这么做目的只有一个,就是不让其它类创建本类对象,交给子类完成
B:
abstract不能和static
被abstract修饰的方法没有方法体
被static修饰的可以用类名,但是类名,调用抽象方法是没有意义的
abstract不能和final
被abstract修饰的方法强制子类重写
被final修饰的不让子类重写,所以他两是矛盾
abstract不能和private
被abstract修饰的是为了不让子类看到并强制重写
被private修饰不让子类访问,所以他两是矛盾的
8、什么是接口，它的特点是什么？
接口:
从狭义的角度讲就是指java中的interface
从广义的角度讲对外提供规则的都是接口
特点:
接口用关键字interface表示
类实现接口用implements接口名{}
接口不能实例化,按照多态的方式来实例化
接口的子类
可以是抽象,但意义不大
可以是具体类.要重写接口中的所有抽象方法
9、接口的成员特点有哪些？
特点:
成员变量只能是常量,并且是静态的并公共的
构造方法:接口没有构造方法
成员方法:只能是抽象方法
10、抽象类和接口的区别是什么?
区别:
成员区别:
抽象类:
成员变量:可以变量,也可以是常量
构造方法:有
成员方法:可以是抽象,也可以是非抽象
接口:
成员变量:只可以常量
成员方法:只可以抽象
抽象类 被继承体现的是：
”is a”的关系。抽象类中定义的是该继承体系的共性功能。
接口 被实现体现的是：
”like a”的关系。接口中定义的是该继承体系的扩展功能。
对事物本质的抽象用抽象类，对事物功能的扩展用接口
11.
/*
需求1：
具体事物:基础班学生,就业班学生
共性:姓名,年龄,学习
特性：
基础班学生学JavaSE
就业班学生学Android
*/
//测试类
class demo
{
public static void main(String args[])
{
Student s=new BaseStudent();
s.setName("小明");
s.setAge(10);
System.out.println(s.getName()+"..."+s.getAge());
s.study();
Student s1=new AdvancedStudent();
s1.setName("小明");
s1.setAge(10);
System.out.println(s1.getName()+"..."+s1.getAge());
s1.study();
}
}
//父类 Student
abstract class Student
{
private String name; //姓名
private int age; //年龄
public Student(){} //无参构造
public Student(String name,int age) //有参构造
{
this.name=name;
this.age=age;
}
public void setName(String name) //设置姓名
{
this.name=name;
}
public String getName() //获取姓名
{
return name;
}
public void setAge(int age) //设置年龄
{
this.age=age;
}
public int getAge() //获取年龄
{
return age;
}
public abstract void study();
}
//基础班学生
class BaseStudent extends Student
{
public BaseStudent(){} //无参构造
public BaseStudent(String name,int age) //有参构造
{
super(name,age);
}
public void study() //重写学习方法
{
System.out.println("学习java基础");
}
}
//就业班学生
class AdvancedStudent extends Student
{
public AdvancedStudent(){} //无参构造
public AdvancedStudent(String name,int age) //有参构造
{
super(name,age);
}
public void study() //重写学习方法
{
System.out.println("学习Android");
}
}
需求2：
已知猫类和狗类：
属性:毛的颜色,腿的个数
行为:吃饭
猫特有行为:抓老鼠catchMouse
狗特有行为:看家lookHome
public class Text1 {
public static void main(String[] args) {
//多态
Animal a1 = new Cat();
a1.setColor("白色");
a1.setLeg(3);
System.out.println(a1.getColor()+ " " + a1.getLeg());
a1.eat();
Cat c = (Cat)a1;
c.catchMouse();
Animal a2 = new Dog();
a2.setColor("黑色");
a2.setLeg(4);
System.out.println(a2.getColor()+ " " + a2.getLeg());
a2.eat();
Dog d = (Dog)a2;
d.lookHome();
}
}
abstract class Animal {
private String color;
private int leg;
public Animal() {
super();
}
public Animal(String color, int leg) {
super();
this.color = color;
this.leg = leg;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public int getLeg() {
return leg;
}
public void setLeg(int leg) {
this.leg = leg;
}
public abstract void eat();
}
// 猫特有行为:抓老鼠catchMouse
class Cat extends Animal {
public void eat() {
System.out.println("猫吃鱼");
}
public void catchMouse() {
System.out.println("抓老鼠");
}
}
// 狗特有行为:看家lookHome
class Dog extends Animal {
public void eat() {
System.out.println("狗吃肉");
}
public void lookHome() {
System.out.println("狗看家");
}
}
//需求三
/*
* 需求:原始的手机，可以发短信，通电话。随着发展，新手机增加了功能：玩游戏。
分析:
1)定义一个抽象类CellPhone 字段是品牌 和价格 发短信 打电话
2)再定义两个类 NewPhone OldPhone 让他两继承 CellPhone
3)定义一个玩游戏的接口 IPlayGame 有一个方法签名 playGame();
4)NewPhone实现IPlayGame接口,重写接口中的方法
5)在测试类中测试
*/
//测试类
class demo
{
public static void main(String args[])
{
CellPhone c=new OldPhone();
c.call();
c.sendMessage();
System.out.println("----------------");
CellPhone c1=new NewPhone();
c1.call();
c1.sendMessage();
NewPhone p=(NewPhone)c1;
p.playGame();
System.out.println("----------------");
IPlayGame pg=new IPlayGame()
{
public void plauGame()
{
System.err.println("新式手机可以玩Dota");
}
}.plagGame();
}
}
//CellPhone
abstract class CellPhone
{
private String brand; //品牌
private int price; //价格
public CellPhone(){} //无参构造
public CellPhone(String brand,int price) //有参构造
{
this.brand=brand;
this.price=price;
}
public void setBrand(String brand) //设置品牌
{
this.brand=brand;
}
public String getBrand() //获取品牌
{
return brand;
}
public void setPrice(int price) //设置价格
{
this.price=price;
}
public int getPrice() //获取价格
{
return price;
}
public abstract void call(); //打电话
public abstract void sendMessage(); //发短信
}
//老手机类
class OldPhone extends CellPhone
{
public OldPhone(){} //无参构造
public OldPhone(String brand,int price) //有参构造
{
super(brand,price);
}
public void call()
{
System.out.println("打电话");
}
public void sendMessage()
{
System.out.println("发短信");
}
}
//玩游戏的接口
interface IPlayGame
{
public abstract void playGame();
}
//新手机类
class NewPhone extends CellPhone implements IPlayGame
{
public void call()
{
System.out.println("打新电话");
}
public void sendMessage()
{
System.out.println("发新短信");
}
public void playGame()
{
System.out.println("玩游戏");
}
}
需求4：
已知动物类（姓名，年龄，吃饭，睡觉），它有两个子类，分别是猫类和狗类。
不同的是猫吃鱼，狗吃肉。
经过马戏团的培训后，部分猫会跳高，部分狗也会跳高。
请写代码实现。
public class Text1 {
public static void main(String[] args) {
//多态
Cat c1 = new JumpCat();
c1.setName("三脚猫");
c1.setAge(3);
System.out.println(c1.getName()+ " " + c1.getAge());
c1.eat();
c1.sleep();
JumpCat c = (JumpCat)c1;
c.jump();
Dog d1 = new JumpDog();
d1.setName("大黑狗");
d1.setAge(4);
System.out.println(d1.getName()+ " " + d1.getAge());
d1.eat();
d1.sleep();
JumpDog d = (JumpDog)d1;
d.jump();
}
}
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();
}
// 猫特有行为:抓老鼠catchMouse
class Cat extends Animal {
public void eat() {
System.out.println("猫吃鱼");
}
public void sleep() {
System.out.println("猫躺着睡");
}
}
// 狗特有行为:看家lookHome
class Dog extends Animal {
public void eat() {
System.out.println("狗吃肉");
}
public void sleep() {
System.out.println("狗趴着睡");
}
}
//经过马戏团的培训后，部分猫会跳高，部分狗也会跳高。
interface Jump {
public void jump();
}
class JumpCat extends Cat implements Jump{
public void jump() {
System.out.println("猫跳高");
}
}
class JumpDog extends Dog implements Jump {
public void jump() {
System.out.println("跳高狗");
}
}
需求5:
(根据上面的猫狗案例，完成下面的汽车案例)
利用面向对象的思想，结合猫狗的案例，仔细分析下面的描述，实现需求！
描述：汽车都具有跑的功能，普通的奥迪车也不例外，但是高端的奥迪车除了具有跑的功能外，
还具有自动泊车和无人驾驶的功能！
需求：定义普通奥迪车，高端奥迪车，实现描述中的功能并测试
public class Text1 {
public static void main(String[] args) {
Car c1 = new LowCar();
c1.setBound("低端车");
System.out.println(c1.getBound());
c1.run();
Car c2 = new HeightCar();
c2.setBound("高级");
System.out.println(c2.getBound());
c2.run();
HeightCar hc = (HeightCar)c2;
hc.automaticPark();
hc.noPersonDrive();
}
}
abstract class Car{
private String Bound;
public Car() {
super();
}
public Car(String bound) {
super();
Bound = bound;
}
public String getBound() {
return Bound;
}
public void setBound(String bound) {
Bound = bound;
}
public abstract void run();
}
class LowCar extends Car {
public void run() {
System.out.println("随便跑");
}
}
class HeightCar extends Car implements AdvancedFunction {
public void run() {
System.out.println("瞎跑");
}
public void automaticPark() {
System.out.println("自动停车");
}
public void noPersonDrive() {
System.out.println("无人驾驶");
}
}
interface AdvancedFunction {
public abstract void automaticPark();
public abstract void noPersonDrive();
}
|
|
收藏
淘帖
踩
