编程题
1、建立一个人类（Person）和学生类（Student）,功能要求如下：
（1）Person中包括四种私有型的数据成员name、addr、sex、age，分别为字符串型，字符串型、字符串型及整形。表示姓名、地址、性别和年龄。一个四参构造方法，一个两参构造方法，一个无参构造方法，一个输出方法显示4中属性。
package com.lxh.eightchapter;
public class Person185 {
private String name;
private String addr;
private String sex;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAddr() {
return addr;
}
public void setAddr(String addr) {
this.addr = addr;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Person185() {
}
public Person185(String name, String addr) {
this("李黑","陕西","男",20);
}
public Person185(String name, String addr, String sex, int age) {
this.name = name;
this.addr = addr;
this.sex = sex;
this.age = age;
}
@Override
public String toString() {
return "Person185 [name=" + name + ", addr=" + addr + ", sex=" + sex + ", age=" + age + "]";
}
}
（2）Student类继承Person类，并增加成员math、english存放数学和英语成绩。一个六参构造方法和一个两参构造方法，一个无参构造方法和输出六中属性。
package com.lxh.eightchapter;
public class Student185 extends Person185 {
private int math;
private int english;
public int getMath() {
return math;
}
public void setMath(int math) {
this.math = math;
}
public int getEnglish() {
return english;
}
public void setEnglish(int english) {
this.english = english;
}
public Student185() {
}
public Student185(String name,String addr) {
super(name,addr);
}
public Student185(String name,String addr,String sex,int age,int math,int english) {
super(name,addr);
this.math=math;
this.english=english;
}
@Override
public String toString() {
return "["+super.toString()+"math=" + math + ", english=" + english + "]";
}
}
package com.lxh.eightchapter;
public class Java185 {
public static void main(String[] args) {
Person185 per=new Person185("李黑","陕西");
System.out.println(per.toString());
Student185 stu=new Student185("张三","陕西","男",20,80,60);
System.out.println(stu.toString());
}
}
执行结果
Person185 [name=李黑, addr=陕西, sex=男, age=20]
[Person185 [name=李黑, addr=陕西, sex=男, age=20]math=80, english=60]
2、定义员工类，具有姓名、年龄、性别属性，并具有构造方法和显示数据方法。定义管理层类，继承员工类，并有自己的属性职务和年薪。定义职员类，继承员工类，并有自己的属性部门和月薪。
package com.lxh.eightchapter;
public class Staff {
private String name;
private int age;
private String sex;
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 String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public Staff() {
}
public Staff(String name, int age, String sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
@Override
public String toString() {
return "Staff [name=" + name + ", age=" + age + ", sex=" + sex + "]";
}
}
package com.lxh.eightchapter;
public class Admin extends Staff {
private String duty;
private double salary;
public String getDuty() {
return duty;
}
public void setDuty(String duty) {
this.duty = duty;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
public Admin() {
}
public Admin(String name, int age, String sex,String duty, double salary) {
super(name,age,sex);
this.duty = duty;
this.salary = salary;
}
@Override
public String toString() {
return "["+super.toString()+"duty=" + duty + ", salary=" + salary + "]";
}
}
package com.lxh.eightchapter;
public class Clerk extends Staff{
private String section;
private double mot;
public String getSection() {
return section;
}
public void setSection(String section) {
this.section = section;
}
public double getMot() {
return mot;
}
public void setMot(double mot) {
this.mot = mot;
}
public Clerk() {
}
public Clerk(String name, int age, String sex,String section, double mot) {
super(name,age,sex);
this.section = section;
this.mot = mot;
}
@Override
public String toString() {
return "["+super.toString()+"section=" + section + ", mot=" + mot + "]";
}
}
package com.lxh.eightchapter;
public class java2185 {
public static void main(String[] args) {
Admin pera=new Admin("李世",50,"男","经理",50000.20);
Clerk per=new Clerk("李雷",20,"男","人事部",500.2);
System.out.println(pera.toString());
System.out.println(per.toString());
}
}
执行结果
[Staff [name=李世, age=50, sex=男]duty=经理, salary=50000.2]
[Staff [name=李雷, age=20, sex=男]section=人事部, mot=500.2]
3、编写程序，统计出字符串want you to konw one thing中的字母n和o的个数？
public class java3185 {
public static void main(String[] args) {
String str="want you to know one thing";
char rest []=str.toCharArray();
int countn=0;
int counto=0;
for(int x=0;x<rest.length;x++) {
int mata=rest[x];
if(mata==110) {
countn++;
}
if(mata==111) {
counto++;
}
}
System.out.println("n的个数为："+countn);
System.out.println("0的个数为："+counto);
}
}
执行结果
n的个数为：4
0的个数为：4
4、建立一个可以实现整形数组的操作类（Array）,类中允许操作的数组大小由外部动态指定，同时在Array类里需要提供有数组以下处理：进行数据的增加（如果数据满了则无法增加），可以实现数组的容量扩充，取得数组全部内容。完成之后再次基础上派生两个子类。
package com.lxh.eightchapter;
public class Array {
private int date[]; //整形数组
private int foot; //数组索引控制
public int[] getDate() {
return date;
}
public void setDate(int[] date) {
this.date = date;
}
public int getFoot() {
return foot;
}
public void setFoot(int foot) {
this.foot = foot;
}
public Array(int len) {
if(len>0) {
this.date=new int[len];//开辟空间
}else {
this.date=new int[1];//开辟一个空间
}
}
//实现数组容量扩充，给出的是扩充大小。实际大小：已有大小+扩充大小
public void increment(int num) {
int [] newdata=new int[this.date.length+num];
System.arraycopy(this.date, 0, newdata, 0, this.date.length);
this.date=newdata;//改变数组引用
}
public boolean add(int num) { //数据增加
if(this.foot<this.date.length) {//有位置
this.date[this.foot++]=num;
return true;
}
return false;
}
}
在这里插入代码片
- 数组排序类：返回的数据必须是排序后的结果。
package com.lxh.eightchapter;
public class SortArray extends Array {
public SortArray(int len) { //定义排序子类
super(len);
}
public int[] getDate() {
java.util.Arrays.sort(super.getDate());
return super.getDate();
}
}
package com.lxh.eightchapter;
public class DemoArray {
public static void main(String[] args) {
SortArray da=new SortArray (5);
System.out.println(da.add(5));
System.out.println(da.add(20));
System.out.println(da.add(52));
System.out.println(da.add(51));
System.out.println(da.add(22));
da.increment(3);
System.out.println(da.add(22));
System.out.println(da.add(2));
System.out.println(da.add(2));
int [] re=da.getDate();
for(int temp:re) {
System.out.println(temp+"、");
}
}
}
执行结果
2、
2、
5、
20、
22、
22、
51、
52、
- 数组反转类：可以实现内容的首尾交换。
package com.lxh.eightchapter;
public class RerverArray extends Array{ //定义反转子类
public RerverArray(int len) {
super(len);
}
public int[] getDate() {
int center=super.getDate().length/2;
int head=0;
int tail=super.getDate().length-1;
for(int x=0;x<center;x++) {
int temp=super.getDate()[head];
super.getDate()[head]=super.getDate()[tail];
super.getDate()[tail]=temp;
head++;
tail--;
}
return super.getDate();
}
}
package com.lxh.eightchapter;
public class DemoArray {
public static void main(String[] args) {
RerverArray da=new RerverArray (5);
System.out.println(da.add(5));
System.out.println(da.add(20));
System.out.println(da.add(52));
System.out.println(da.add(51));
System.out.println(da.add(22));
da.increment(3);
System.out.println(da.add(22));
System.out.println(da.add(2));
System.out.println(da.add(2));
int [] re=da.getDate();
for(int temp:re) {
System.out.println(temp+"、");
}
}
}
执行结果
2、
2、
22、
22、
51、
52、
20、
5、
填空题
1、 Java中通过 extends 关键字实现继承。
2、 Object 类是所有类的父类，该类中判断两个对象是否相等的方法是 public boolean equals(Object obj) ，取得对象完整信息的方法是 public String toString() 。
3、 当子类中定义的方法与父类方法同名且参数类型及个数、返回值类型相同时，称子类方法 覆写 父类方法，子类默认使用 本类已经覆写 方法，使用父类的同名方法，必须使用 super 关键字说明。
4、 当子类定义的成员变量与父类的成员变量同名时，称子类 覆盖 父类的成员变量，子类默认使用 本类 属性。使用父类的同名成员变量，必须用 super 关键字说明。
5、 如果子类定义了构造方法，在创建子类对象时首先默认调用 父类无参构造方法 ，然后再本类的构造方法。
6、 Java提供的三个内建的Annotation是： @Override 、 @Deprecated 、 @SuppressWarnings 。
选择题
1、 为类定义多个名称相同、但参数的类型或个数不同的方法的做法称为 A 。
A、 方法重载 B、 方法覆写 C、 方法继承 D、 方法重用
2、 现在有两个类A、B，以下描述中表示B继承自A的是 D 。
A、 class A extends B B、 class B implements A
C、 class A implements D、 class B extends A
3、 下面关于子类调用父类构造方法的描述正确的是 C 。
A、 子类定义了自己的构造方法，就不会调用父类的构造方法。
B、 子类必须通过super关键字调用父类有参的构造方法。
C、 如果子类的构造方法没有通过super调用父类的构造方法，那么子类会先调用父类中无参构造方法，之后再调用子类自己的构造方法。
D、 创建子类对象时，先调用子类自己的构造方法，让后再调用父类的构造方法。
4、 假设类X是类Y的父类，下列声明对象x的语句中不正确的是 D 。
A、 X x = new X() ; B、 X x = new Y() ;
C、 Y x = new Y() ; D、 Y x = new X() ;
5、 编译并运行下面的程序，结果 B 。
public class A {
public static void main(String args[]) {
B b = new B();
b.test();
}
void test() {
System.out.print(“A”);
}
}
class B extends A {
void test() {
super.test();
System.out.println(“B”);
}
}
A、 产生编译错误 B、 代码可以编译运行，并输出结果：AB
C、 代码可以编译运行，但没有输出 D、 编译没有错误，但会运行时会产生异常
6、 编译运行下面的程序，结果是 A 。
public class A {
public static void main(String args[]) {
B b = new B();
b.test();
}
public void test() {
System.out.print(“A”);
}
}
class B extends A {
void test() {
super.test();
System.out.println(“B”);
}
}
A、 产生编译错误，因为类B覆盖类A的方法test()时，降低了其访问控制的级别。
B、 代码可以编译运行，并输出结果：AB
C、 代码可以编译运行，但没有输出
D、 代码可以编译运行，并输出结果：A
7、 现在有两个类A、B，以下描述中表示B继承自A的是 D 。
A、 class A extends B B、 class B implements A
C、 class A implements D、 class B extends A
8、 下面 A 修饰符所定义的方法不能被子类所覆写。
A、 final B、 abstract D、 static D、 interface
判断题
1、 一个类不能即是子类又是父类。 （ √ ）
2、 子类只能继承父类的成员，但不能修改父类成员。 （ × ）
3、 Java语言只支持单继承，不支持多继承。 （ √ ）
4、 子类可以继承父类的所有成员。 （ √ ）
简答题
1、 举例说明子类对象的实例化过程。
答： 当通过关键字new实例化子类对象时，会默认调用父类的无参构造方法，为父类对象实例化，而后才会调用子类的构造方法，为子类对象实例化。
2、 简述this与super关键字的区别。
答： this和super都可以调用类中的属性、方法、构造方法，但是this调用的是本类操作，而super是由子类调用父类操作。
3、 简述方法的重载与覆写的区别。
答： 方法重载是发生在一个类之中，方法名称相同、参数的类型及个数不同，不受权限的限制。而覆写是发生在继承关系之中，子类定义了和父类定义了方法名称相同、参数类型及个数、返回值类型完全相同的方法时所发生的操作，在子类覆写父类方法时，被覆写的方法不能拥有比父类更严格的访问权限。
4、 在已有类的基础上派生新的类有什么好处？
答： 扩充已有类的功能，并且利用方法的覆写扩充已有方法的功能。
5、 如何区分子类和父类？子类可以继承父类的那些内容？
答： 子类使用extends继承父类，子类可以继承父类中的全部内容，但是对于私有操作属于隐式继承，而非私有操作属于显式继承。
6、 什么是多态？实现都态的方法有那些？
答： 多态性主要分为两个方面：
· 方法的多态性：重载与覆写
|- 重载：同一个方法名称，根据不同的参数类型及个数可以完成不同的功能；
|- 覆写：同一个方法，根据操作的子类不同，所完成的功能也不同。
· 对象的多态性：父子类对象的转换。
|- 向上转型：子类对象变为父类对象，格式：父类 父类对象 = 子类实例，自动；
|- 向下转型：父类对象变为子类对象，格式：子类 子类对象 = (子类) 父类实例，强制；
7、 简述JAVA SE中三个内建的Annotation的作用。
· @Override：准确的方法覆写；
· @Deprecated：某个结构（类、方法、属性）不再建议被用户所使用；
· @SuppressWarnings：压制编译时所产生的警告信息。
