第二阶段面向对象扩展加强训练习题.docx
《第二阶段面向对象扩展加强训练习题.docx》由会员分享，可在线阅读，更多相关《第二阶段面向对象扩展加强训练习题.docx（29页珍藏版）》请在冰豆网上搜索。
第二阶段面向对象扩展加强训练习题
面向对象加强补充扩展作业
理论题
1.局部变量和成员变量的区别：
A、在位置上：
成员变量：
在类中方法外；
局部变量：
在方法中或者方法声明上
B、在内存中：
成员变量：
在堆内存中
局部变量：
在栈内存中
C、生命周期：
成员变量：
随着对象的创建而存在，随着对象的消失而消失；
局部变量：
随着方法的调用而存在，随着方法的调出完毕而消失
D、默认初始化值：
成员变量：
有默认的初始化值；
局部变量：
没有初始化值，必须赋值之后才能使用
2.变量的使用顺序？
3.类和对象的关系？
1、类是一组相关属性和行为的集合
2、对象是该类事物的个体体现；
3、类是抽象的具体的或者是类是一般的，对象是特殊的
4、类中可以包含成员变量、类变量、成员方法、类方法、构造函数、构造代码块儿、静态代码块
4.java描述事物最基本的单位？
类
5.什么叫面向对象？
强调的对象，不断的创建对象，使用对象，强调对象的方法做事情；
6.什么是封装？
封装的原则？
好处？
封装是隐藏属性和其实现细节，只提供对外公共访问方式；
隐藏属性和实现细节，只提供对外公共访问方式
好处：
1、提高代码的复用性；2、提高代码的维护性；
7.封装就是私有，对吗？
为什么？
不对，私有只是封装的一种，
8.Java中参数传递的问题：
传递基本数据类型和引用数据类型区别?
9.构造方法，set方法都可以给成员变量赋值，这两种赋值方式有什么区别？
10.static关键字的特点？
注意事项是什么？
有什么好处和弊端？
特点：
1、随着类的加载而加载，加载到方法区下；
2、优先于对象存在；
3、被所有对象共享；
4、静态的成员变量或者成员方法都是可以通过类名来调用，也可以使用对象名来调用，但是推荐使用类名来调用，在开发中，通常都是以类名来调用；
注意事项：
静态修饰成员，类成员，静态成员变量又称为类变量；
11.类变量和实例变量的区别？
静态变量属于类，所以也称为类变量
成员变量属于对象，所以也称为实例变量（对象变量）
12.构造方法能不能重载？
可以，既然是方法，就可以重载
13.静态代码块和构造代码块的区别？
静态代码块：
随着类的加载而执行，而且只执行一次
构造代码块：
每次执行构造方法之前执行
14.什么是继承？
让类和类之间产生了关系，子父类关系
15.继承的的特点和好处，弊端？
好处：
1、提高代码的复用性；
2、提高了代码的维护性；
3、让类与类之间产生了关系，是多态的前提；
弊端：
让类与类之间的依赖性增强了，也就是耦合性增强了
开发的原则：
高内聚，低耦合；
16.this和super的区别？
1、调用成员变量
This.成员变量调用本类的成员变量，也可以调用父类的成员变量
Super.成员变量调用父类的成员变量
2、调用构造方法
This（）调用本类的构造方法
Super（）调用父类的构造方法
3、调用成员方法
This.成员方法，调用本类的成员方法，也可以调用父类的成员方法；
Super.成员方法，调用父类的成员方法
17．Super（）和this（）在构造方法能同时使用吗？
Super（）或者this（）必须出现在构造方法的第一条语句上，只能出现其一
18.Super关键字和this关键字能否在构造函数中共存？
19.为什么每个构造函数中第一行都有默认的super（）?
20.为什么默认的super（）都是空参的呢？
21.构造方法的特点？
1、构造方法主要作用是给对象的属性进行初始化；
2、方法名与类名完全一致，没有返回值类型，连void都没有
3、构造方法也是方法，只是比较特殊，是在创建对象后马上调用，后期不能单独调用，既然是方法，就可以重载；
22.this的作用？
代表当前对象的引用
23.子父类都有静态代码块，构造代码块，构造方法的执行顺序？
父类静态代码块、子类静态代码块、父类构造代码块、构造方法、子类构造代码块、子类构造方法
24.final修饰的变量的初始化时机：
1、未被static关键字修饰：
可以显示初始化，可以在构造方法中初始化
2、被static修饰，可以显示初始化，可以在静态代码块中初始化，不能在构造方法中初始化；
25.final如果修饰局部变量，会发生什么事情？
Final修饰局部变量:
基本类型：
其值不能被改变；引用类型：
是地址值不能被改变，对象中的属性可以改变；
26.什么是多态？
多态的体现，前提，好处和弊端分别是什么？
多态：
多态就是事物存在的多种形态
前提：
要有继承关系
要有方法重写
要有父类引用指向子类对象
好处：
提高代码的复用性和维护性；
提高代码的扩展性；父类作参数时候
弊端：
不能使用子类的特有属性和行为
27.什么是向上转型和向下转型?
向上转型：
父类的引用指向子类对象；
向下转型：
把父类的引用转换子类，用子类强转父类的引用
28.多态中成员方法和变量的特点？
成员方法：
编译时看父类（左边），运行时看子类（右边）
成员变量：
编译时看父类（左边），运行时看父类（左边）
29.抽象类和抽象方法的特点，有什么关系？
1、抽象类和抽象方法必须用abstract关键字修饰
2、抽象类不一定有抽象方法，有抽象方法的类一定是抽象类或者接口
3、抽象类不能实例化，按照多态的方式，由具体的子类实例化；
抽象类中的子类，要么是抽象类，要么要重写抽象类中的所有抽象方法；
30.抽象类中的抽象方法和非抽象方法的区别？
抽象方法：
强制要求子类做的事情；
非抽象方法：
子类继承的事情，提高代码复用性
31.abstract不能和哪些关键字共同存在？
1、abstraet和static:
被abstract修饰的方法没有方法体，被static修饰的可以是类名，但是类名，调用抽象方法是没有意义的；
2、abstract和final：
abstract修饰的方法强制子类重写，被final修饰的不让子类重写，所以他们是矛盾的；
3、abstract和private：
被abstract修饰的是为了让子类看到并强制重写，被private修饰不让子类访问，所以他们是矛盾的
32.final修饰的变量、方法、和类有什么特点？
Final修饰的变量变常，只能被赋值一次；final修饰的方法不能被重写；final修饰的类不能被继承；
33.接口中的成员的特点？
特点：
1、成员变量只能是常量，并且是静态的并公共的。
2、构造方法：
接口没有构造方法；
3、成员方法：
只能是抽象方法。
34、类与类、类与接口、接口与接口的关系？
1、类与类：
继承关系，只能单继承，可以多层继承；
2、类与接口：
实现关系，可以单实现，也可以多实现；并且还可以在继承一个类的同时实现多个接口；
3、接口与接口：
继承关系，可以单继承，也可以多继承；
35.接口和抽象类的区别？
1、成员区别：
抽象类：
成员变量：
可以变量，也可以常量；
构造方法：
有
成员方法：
可以抽象，也可以非抽象
接口：
成员变量：
只可以常量
构造方法：
没有
成员方法：
只可以抽象
2、关系区别：
类与类：
继承，单继承，
类与接口:
实现，单实现，多实现
接口与接口：
继承，单继承，多继承
3、设计理念区别：
抽象类：
被继承体现的是：
isa的关系。
抽象类中定义的是该继承体系的共性功能
接口：
被实现体现的是：
likea的关系。
接口中定义的是该继承体系的扩展功能
对事物本质的抽象用抽象类，对事物功能的扩展用接口
36.接口的思想特点？
特点：
1、接口用关键字interface表示interface接口名｛｝
2、类实现接口用implements表示，class类名implements接口名
3、接口不能实例化：
按照多态的方式来实例化
4、接口的子类：
可以是抽象类但是意义不大，可以是具体类要重写接口中的所有抽象方法
37．什么是内部类，特点是什么？
内部类：
书写一个类里面，成员内部类；
特点：
1、可以直接访问外部类的成员，包括私有的
2、如果外部需要访问内部类的成员时候，需要创建外部类、内部类对象
38.成员内部类是什么？
39．内部类的方法如果访问局部变量，内部类的成员变量，外部类的成员变量？
内部类需要访问局部变量的时候，这个局部变量需要添加final;可以直接访问外部类的成员变量；
40.局部内部类访问的局部变量为什么要用final修饰？
因为当调用这个方法时，局部变量如果没有用final修饰，他的生命周期和方法的生命周期是一样的，当方法弹栈，这个局部变量也会消失，那么如果局部内部类对象还没有马上消失想用这个局部变量，就没有了，如果用final修饰会在类加载的时候进入常量池，即使方法弹栈，常量池的常量还在，也可以继续使用；
41．什么是匿名内部类？
写在方法里面的
42、匿名对象何时使用？
43.四种权限修饰符的比较？
Public>protected>默认>private
44.package,import,class使用顺序?
Package:
放在语句的第一行；
Import:
放在package下面，class上面，可以有多个
Class:
放在import下面，
45.代码块的分类?
静态代码块、构造代码块、局部代码块、同步代码块；
编程题
1、使用面向对象方式描述猫狗类/学生老师类/员工类/长方形类
猫狗类
classTest_Animal{
publicstaticvoidmain（String[]args）{
Catc=newCat（）;
//c.Cat（"大花猫",4,18.0）;
c.setColor（"大花猫"）;
c.setLeg（4）;
c.setWeight（19.0）;
c.eat（）;
c.sleep（）;
System.out.println（"这是一只懒懒的"+c.getColor（）+"-----"+c.getLeg（）+"-----"+c.getWeight（））;
System.out.println（"-----------------------------"）;
Dogd=newDog（"大黑狗",3,18.8）;
d.eat（）;
d.sleep（）;
System.out.println（d.getColor（）+"------"+d.getLeg（）+"------"+d.getWeight（））;
System.out.println（"-----------------"）;
singple（newCat（"小白猫",4,18.9））;
singple（newDog（"小黄狗",4,8.9））;
}
publicstaticvoidsingple（Animala）{//使用父类作为参数
a.eat（）;
a.sleep（）;
}
}
abstractclassAnimal{//创建父类Animal
privateStringcolor;//定义成员变量
privateintleg;
privatedoubleweight;
publicAnimal（）{
System.out.println（"这是父类的无参构造"）;
}
publicAnimal（Stringcolor,intleg,doubleweight）{
this.color=color;
this.leg=leg;
this.weight=weight;
}
publicvoidsetColor（Stringcolor）{
this.color=color;
}
publicStringgetColor（）{
returncolor;
}
publicvoidsetLeg（intleg）{
this.leg=leg;
}
publicintgetLeg（）{
returnleg;
}
publicvoidsetWeight（doubleweight）{
this.weight=weight;
}
publicdoublegetWeight（）{
returnweight;
}
publicabstractvoideat（）;
publicabstractvoidsleep（）;
}
classCatextendsAnimal{
publicCat（）{
System.out.println（"这是子类猫的无参构造"）;
}
publicCat（Stringcolor,intleg,doubleweight）{
super（color,leg,weight）;
}
publicvoideat（）{//重写抽象方法
System.out.println（"猫喜欢吃鱼"）;
}
publicvoidsleep（）{///重写抽象方法
System.out.println（"猫睡觉萌萌的"）;
}
}
classDogextendsAnimal{
publicDog（）{//空参构造
System.out.println（"这是狗的空参构造"）;
}
publicDog（Stringcolor,intleg,doubleweight）{//有参构造
super（color,leg,weight）;
}
publicvoideat（）{//重写抽象方法
System.out.println（"狗喜欢吃骨头"）;
}
publicvoidsleep（）{//重写抽象方法
System.out.println（"狗喜欢大白天的睡觉"）;
}
}
学生老师类
classTest_person{
publicstaticvoidmain（String[]args）{
students=newstudent（）;
s.sleep（）;
s.setName（"adele"）;
s.setAge（28）;
s.setGentle（'女'）;
System.out.println（"英国女歌手"+s.getName（）+",年龄"+s.getAge（）+",特别有才华的"+s.getGentle（）+"歌手"）;
teachert=newteacher（"钟老师",28,'男'）;
t.sleep（）;
System.out.println（t.getName（）+"是个很负责任的老师，年龄"+t.getAge（）+",姓别"+t.getGentle（））;
}
}
abstractclassperson{
privateStringname;
privateintage;
privatechargentle;
publicperson（）{}
publicperson（Stringname,intage,chargentle）{
this.name=name;
this.age=age;
this.gentle=gentle;
}
publicvoidsetName（Stringname）{
this.name=name;
}
publicStringgetName（）{
returnname;
}
publicvoidsetAge（intage）{
this.age=age;
}
publicintgetAge（）{
returnage;
}
publicvoidsetGentle（chargentle）{
this.gentle=gentle;
}
publicchargetGentle（）{
returngentle;
}
publicabstractvoidsleep（）;
}
classstudentextendsperson{
publicstudent（）{}
publicstudent（Stringname,intage,chargentle）{
super（name,age,gentle）;
}
publicvoidsleep（）{
System.out.println（"学习睡觉都比较早"）;
}
}
classteacherextendsperson{
publicteacher（）{}
publicteacher（Stringname,intage,chargentle）{
super（name,age,gentle）;
}
publicvoidsleep（）{
System.out.println（"老师批发作业到很晚才睡"）;
}
}
员工类
classTest1_Employee{
publicstaticvoidmain（String[]args）{
coderc=newcoder（"小明",18000.0,"88888"）;//有参构造进行赋值
c.work（）;
System.out.println（"----------------"）;
managerm=newmanager（"小贱",28888.0,"33333",8888）;
m.work（）;
System.out.println（"-----------------"）;
employer（newcoder（"小华",19999.9,"999"））;
employer（newmanager（"小龙",29999.9,"000",8999））;
}
publicstaticvoidemployer（Employeee）{//定义方法，父类作为参数
e.work（）;
}
}
abstractclassEmployee{//创建类
privateStringname;//定义姓名
privatedoublesalary;//定义薪水
privateStringid;//定义工号
publicEmployee（）{}//空参构造
publicEmployee（Stringname,doublesalary,Stringid）{//有参构造
this.name=name;
this.salary=salary;
this.id=id;
}
publicvoidsetName（Stringname）{//设置姓名
this.name=name;
}
publicStringgetName（）{//获取姓名
returnname;
}
publicvoidsetSalary（doublesalary）{//设置薪水
this.salary=salary;
}
publicdoublegetSalary（）{//获取薪水
returnsalary;
}
publicvoidsetId（Stringid）{
this.id=id;
}
publicStringgetId（）{
returnid;
}
publicabstractvoidwork（）;//定义抽象方法
}
classcoderextendsEmployee{//子类coder继承父类Employee;
publiccoder（）{}
publiccoder（Stringname,doublesalary,Stringid）{
super（name,salary,id）;
}
publicvoidwork（）{//方法重写
System.out.println（"我是程序员"+getName（）+",我的工资是"+getSalary（）+",我的工号为"+getId（）+",每天的工作就是不断的敲代码"）;
}
}
classmanagerextendsEmployee{//创建子类manager
privateintbonus;//定义特有属性
publicmanager（）{}
publicmanager（Stringname,doublesalary,Stringid,intbonus）{
super（name,salary,id）;
}
publicvoidwork（）{//方法重写
System.out.println（"我是项目经理"+getName（）+",我的工资是"+getSalary（）+",我的工号为"+getId（）
+",每天的工作分配任务给程序员"+"每个月的奖金"+bonus）;
}
}
矩形类
classTest1_Rectangle{
publicstaticvoidmain（String[]args）{
rectangler=newrectangle（20,30）;
System.out.println（"矩形的周长为：
"+r.getLength（））;
System.out.println（"矩形的面积为：
"+r.getArea（））;
System.out.println（"-----------------------"）;
rectangler1=newrectangle（）;
r1.setWidth（50）;
r1.setHigh（100）;
System.out.println（"矩形1的周长为：
"+r1.getLength（））;
System.out.println（"矩形1的面积为：
"+r1.getArea（））;
}
}
classrectangle{
privateintwidth;//定义矩形的宽
privateinthigh;//定义矩形的高
publicrectangle（）{}//
升级会员 