A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 雪莲 中级黑马   /  2016-7-2 22:42  /  868 人查看  /  0 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

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();
}

0 个回复

您需要登录后才可以回帖 登录 | 加入黑马