1:多态中什么是向上转型?什么是向下转型?
向上转型:
Fu f = new Zi();
向下转型:
Zi z = (Zi)f; //要求该f必须是能够转换为Zi的
总的来说,向上转型总是安全的,向下转型则未必,可能会发ClassCastException.
2:抽象类概述及其特点?
抽象类:abstract关键字,用于修饰方法和类,有抽象方法的类必须是抽象类
注意:如果一个类继承了抽象类,需要重写它所有的抽象方法,或者将这个类也修饰成抽象类。、
抽象类特点
a.抽象方法只能在抽象类里面。
b.抽象类和抽象方法必须被abstract修饰。
c.抽象类不能创建对象(即不能实例化)。
d.抽象类中可以有非抽象方法。
e.抽象类和类的关系也是继承。
f.如果一个类继承了抽象类,要么重写所有抽象方法,要么自己也成为抽象类。
3:抽象类成员特点?
抽象类的成员特点
成员变量:可以有成员变量也可以有常量
成员方法:可以有抽象方法也可以有非抽象方法
构造方法:可以有构造方法,需要对抽象类的成员变量进行初始化
4:抽象类编程题
公司很多员工,而程序员也属于员工,他有姓名,工号,工资的属性,
经理也属于员工,除了上述属性外,还有奖金属性,请使用面向对象方式处理;
abstract class Employee{
//成员变量
private String name ; //姓名
private String id ; //工号 (公司名字+部门名字 +编号)
private int salary ; //工资
//无参构造方法
public Employee(){}
//有参构造方法
public Employee(String name ,String id,int salary){
this.name = name ;
this.id = id ;
this.salary = salary;
}
//提供setxxx/getXXX()方法
public void setName(String name){
this.name = name ;
}
public String getName(){
return name ;
}
public void setId(String id) {
this.id = id ;
}
public String getId(){
return id ;
}
public void setSalary(int salary){
this.salary = salary ;
}
public int getSalary(){
return salary ;
}
//员工分为很多,每一个员工的工作不一样,抽象功能
public abstract void work();
}
//程序员类
class Programmer extends Employee{
public Programmer(){}
public Programmer(String name,String id,int salary){
super(name,id,salary) ;
}
//work
public void work(){
System.out.println("程序员没日没夜的coding...") ;
}
}
//经理类
class Manager extends Employee{
//特有属性
private int bonus ;//奖金属性
public Manager(){}
public Manager(String name,String id,int salary,int bonus){
super(name,id,salary) ;
this.bonus = bonus; //成员变量隐藏局部变量
}
public void setBonus(int bonus){
this.bonus = bonus ;
}
public int getBonus(){
return bonus;
}
//work
public void work(){
System.out.println("经理没日没夜的跟甲方喝酒谈项目...") ;
}
}
//测试类
class AbstractTest3{
public static void main(String[] args){
//测试程序员
//多态
Employee em = new Programmer() ; //抽象类多态
em.setName("cong") ;
em.setId("1000");
em.setSalary(8000) ;
System.out.println(em.getName()+"---"+em.getId()+"----"+em.getSalary());
em.work() ;
//有参构造
em = new Programmer("张","1111",8000) ;
System.out.println(em.getName()+"---"+em.getId()+"----"+em.getSalary());
em.work() ;
//经理类
//em = new Manager() ;
//因为奖金属性是经理特有属性,直接使用经理类对象访问
Manager m = new Manager() ;
m.setName("gao") ;
m.setId("007") ;
m.setSalary(12000) ;
m.setBonus(8000) ;
System.out.println(m.getName()+"---"+m.getId()+"----"+m.getSalary()+"---"+m.getBonus());
m.work();
Manager m2 = new Manager("秋香","008",7000,8000) ;
System.out.println(m2.getName()+"---"+m2.getId()+"----"+m2.getSalary()+"---"+m2.getBonus());
m2.work();
}
}
5:抽象 abstract和哪些关键字冲突,为什么?
abstract::表明希望被重写,即该类中的方法被继承后需要重写。
1.private
被private修饰的方法,子类不能继承到,故不能重写,也就不能共存
2.final
final修饰的类不能被继承,方法不能被重写,变量不能更改值,故不能共存
3.static
static能被实例化直接调用,即不需要依赖对象就可进行访问,而abstract不能被实例化,故不能共存
6:接口的概述及其特点?
从狭义的角度讲就是指java中的interface
从广义的角度讲对外提供规则的都是接口
接口特点:
1、接口中定义的全都是抽象方法。
2、接口用关键字interface表示。即interface 接口名 { }
3、类实现接口用implements表示。即class 类名 implements 接口名 { }
4、接口不能实例化。
那么,接口如何实例化呢?按照多态的方式来实例化。
接口的子类
可以是抽象类,但是意义不大。
可以是具体类,要重写接口中所有的抽象方法。(推荐方案)
7:接口的成员特点?
接口的成员特点:
成员变量:
有默认修饰符:public static final
接口中的变量只能是常量
构造方法:
接口中没有构造方法
成员方法:
只能是抽象方法,默认修饰:public abstract
8:抽象类和接口的区别?
1)成员的区别
抽象类:
成员变量:既可以使用常量,也可以使用变量
构造方法:存在,可以无参的,也可以是有参的,抽象类不能实例化,需要通过子类进行数据初始化
成员方法:
可以抽象方法,也可以非抽象方法!
接口:
成员变量:只能是常量,存在默认的修饰符public static final
构造方法:不存在
成员方法:默认修饰符 public abstract (可以不写),建议给出来
2)关系区别
类与类之间的关系:
继承关系(extends),只支持单继承,不支持多继承,但是可以多层继承
类与接口之间的关系:
实现关系(implements),一个具体类实现一个接口
Jdk—>Object类:所有类的根类,
一个类继承另一个类的同时,可以实现多个接口
接口与接口之间的关系:
继承关系(extends),单继承,支持多继承
3)设计理念:
抽象类(类与类之间的关系):体现的是"is a"的关系,A类是B类的一种/B类是A类的一种
接口(实现关系:类与接口之间的关系):体现的是一种"like a"的关系,主要描述的一种扩展功能
9:接口的编程题
第一题:
教练和运动员案例(学生分析然后讲解)
乒乓球运动员和篮球运动员。
乒乓球教练和篮球教练。
为了出国交流,跟乒乓球相关的人员都需要学习英语。
请用所学知识:
分析,这个案例中有哪些抽象类,哪些接口,哪些具体类,并且进行测试,代码实现
//定义学英语借口
interface English{
public abstract void speak();
}
abstract class Person{
private String name;
private int age;
//无参构造
public Person() {}
//有参构造
public Person(String name,int age) {
this.age=age;
this.name=name;
}
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 eat();
public void sleep() {
System.out .println("人都要睡觉");
}
}
class Player extends Person{
public Player() {super();}
public Player(String name,int age) {
super(name,age);
}
public void eat() {
System.out.println("player eats....");
}
public void stu() {
System.out.println("player....");
}
}
class Coach extends Person{
public Coach() {}
public Coach(String name,int age) {
super(name,age);
}
public void eat() {
System.out.println("coach eats....");
}
public void coa() {
System.out.println("coach....");
}
}
class PingpangPlayer extends Player implements English{
public PingpangPlayer() {}
public PingpangPlayer(String name,int age) {
super(name,age);
}
public void speak() {
System.out.println("pingp player studies English....");
}
public void eat() {
System.out.println("pingp player eats food... ");
}
}
class PingpangCoach extends Coach implements English{
public PingpangCoach() {}
public PingpangCoach(String name,int age) {
super(name,age);
}
public void speak() {
System.out.println("pingp coach studies English....");
}
public void eat() {
System.out.println("pingp coach eats food... ");
}
}
class BasketballPlayer extends Player{
public BasketballPlayer() {}
public BasketballPlayer(String name,int age) {
super(name,age);
}
public void eat() {
System.out.println("bsk Player eats food... ");
}
}
class BasketballCoach extends Coach{
public BasketballCoach() {}
public BasketballCoach(String name,int age) {
super(name,age);
}
public void eat() {
System.out.println("bsk coach eats food... ");
}
}
class test{
public static void main(String[] args) {
PingpangPlayer p1=new PingpangPlayer();
p1.eat();
p1.sleep();
p1.speak();
PingpangCoach p2=new PingpangCoach();
p2.eat();
p2.sleep();
p1.speak();
BasketballPlayer b1=new BasketballPlayer();
b1.eat();
b1.sleep();
BasketballCoach b2=new BasketballCoach();
b2.eat();
b2.sleep();
//多态
Person p=new Player();
Player pp=(Player)p;
pp.stu();
}
}
第二题
猫和狗都属于动物,他们都有吃饭和睡觉的功能,但是具体吃饭和睡觉也是不一样的,并且同时部分猫和狗有跳高的功能,请使用你掌握所学的知识进行分析存在哪些类,哪些接口,哪些是抽象类并且代码实现
定义一个跳高接口。再定义两个类:跳高猫,继承猫,实现猫的跳高接口;跳高狗,继承狗,实现狗的跳高接口。
abstract class Animal {
private String name; //姓名
private int age; //年龄
public Animal() {} //空参构造
public Animal(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 eat(); //吃饭
public abstract void sleep(); //睡觉
}
interface Jumping { //跳高的接口
public void jump();
}
class Cat extends Animal {
public Cat() {} //空参构造
public Cat(String name,int age) {//有参构造
super(name,age);
}
public void eat() {
System.out.println("猫吃鱼");
}
public void sleep() {
System.out.println("侧着睡");
}
}
class JumpCat extends Cat implements Jumping {
public JumpCat() {} //空参构造
public JumpCat(String name,int age) {//有参构造
super(name,age);
}
public void jump() {
System.out.println("猫跳高");
}
}
class test {
public static void main(String[] args) {
Cat c = new Cat("加菲",8);
c.eat();
c.sleep();
JumpCat jc = new JumpCat("跳高猫",3);
jc.eat();
jc.sleep();
jc.jump();
}
}
第三题
/*
老师和学生案例,加入抽烟的额外功能
分析:
从具体到抽象
Teacher类
成员变量:姓名,年龄
成员方法:setXXX()getXXX()
eat(){}
smoke{}
teach(){} 特有功能
构造方法:无参构造/有参构造
Student类
成员变量:姓名,年龄
成员方法:setXXX()getXXX()
eat(){}
smoke{}
study(){} 特有功能
构造方法:无参构造/有参构造
将共性内容抽取----->Person类 ----->抽象类
将eat功能抽象,
抽烟的老师---->属于老师的一种
抽烟的学生---->属于学生的一种
接口:抽烟 额外的功能(扩展功能)
smoking() ;抽象功能
实现:
从抽象到具体
接口
抽象类Person
Teacher
SmokeTeacher
Student
SmokeStudent
*/
//定义一个接口
interface Smoke{
//抽象方法
void smoking() ;//隐藏默认修饰符public abstract
}
//抽象类:人类
abstract class Person{
private String name ;//姓名
private int age ; //年龄
public Person(){}
public Person(String name,int age){
this.name=name;
this.age=age;
}
//公共setxxx()/getXXX()
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 eat() ;
}
//定义一个老师类
class Teacher extends Person{
public Teacher(){}
public Teacher(String name,int age){
super(name,age) ;
}
//重写eat()
public void eat(){
System.out.println("老师喝小米稀饭...") ;
}
public void teach(){
System.out.println("老师教学生学习JavaEE...");
}
}
//部分老师抽烟
class SmokeTeacher extends Teacher implements Smoke{
public SmokeTeacher(){}
public SmokeTeacher(String name,int age){
super(name,age) ;
}
//经过学习,会抽烟了
public void smoking(){
System.out.println("老师会抽烟了...");
}
}
//抽烟的学生自己测试
//测试类
class InterfaceTest{
public static void main(String[] args){
/*
继承中关系:
子类的构造方法(无参/有参),默认父类的无参构造方法,一定要保证子类中的构造方法中的一个要访问父类的无参
*/
//测试:创建具体类对象
SmokeTeacher st = new SmokeTeacher() ;
st.setName("高圆圆");
st.setAge(39);
System.out.println(st.getName()+"----"+st.getAge());
st.eat();
st.teach();
st.smoking();
System.out.println("-----------------------");
//有参赋值
st = new SmokeTeacher("赵又廷",42) ;
System.out.println(st.getName()+"----"+st.getAge());
st.eat();
st.teach();
st.smoking();
}
}