1:final关键字可以干什么?有什么特点?
答:
1)字符final:表示最终,终态(不能被更改的意思)
修饰类,该类不能被继承;
修饰成员方法,该方法不能被重写;
修饰成员变量,该变量初始化后是一个常量;
常量类别:
字面值常量;
自定义常量(final修饰的)public final int a=12;
2)final不仅可以修饰基本数据类型,还可以引用类型
如果final修饰的是一个基本数据类型:基本数据类型的值不能再改变了...
如果final修饰的是一个引用类型数据:引用类型的地址值不能再改变了,但是堆内存中的成员变量的值可以改变;
final的初始化时机:
1)被final只能被赋值一次(final int a = 10 )
final int a ;
答: 面试题:final,finally,finalize的区别?
字符final:表示最终,终态(不能被更改的意思)
修饰类,该类不能被继承;
修饰成员方法,该方法不能被重写;
修饰成员变量,该变量初始化后是一个常量;
常量类别:
字面值常量;
自定义常量(final修饰的)public final int a=12;
3:多态是什么,前提是什么?
答:
多态:在同一时刻,体现出来的不同状态.
多态的前提:1)必须有继承
2)必须有方法重写
3)必须有父类引用指向子类对象(向上转型)
4:多态中成员访问的特点?
答:1)成员变量:编译看左,运行看左边
2)成员方法(静态的):编译看左,运行看右边
3)构造方法:子类和父类的构造方法都是对对象进行初始化的
4)静态成员方法:编译看左运行也看左(静态方法跟类有关系算不上方法重写)
5:多态的好处及弊端?如何解决多态的弊端?
答:
多态好处:1)提高代码的复用性,继承体现
2)提高代码的扩展性,多态体现(父类的引用指向子类对象)
多态弊端:不能访问子类特有功能
解决:向下转型,将父类的引用强制转换成子类引用
6:什么是向上转型?什么是向下转型?
答:向上转型:子类引用的对象指向父类类型
向下转型:父类引用的对象指向子类类型
7:抽象类概述及其特点?
答: 抽象类的概念:
针对一个事物,比如:动物类---->总体概括,之前定一个具体的动物(---->必须给他的某个功能只是声明即可),只有,猫或者狗等等这些才是具体事物
Java中,如果一个类中有一个方法声明(抽象方法)抽象功能,那么这个类定义为抽象类
特点:抽象类不能实例化
抽象类:1)如果一个类中有抽象方法,那么这个类必须是抽象类
2)抽象类中不一定有抽象方法
抽象类的子类:
1)抽象类的子类是抽象类没有意义,不能实例化(不能创建对象)
2)子类是具体类,必须实现父类的抽象功能
8:抽象类成员特点?
答:
成员变量:可以是变量也可以是常量
构造方法:可以有无参构造,也可以有有参构造;都是对对象进行初始化
成员方法:可以是抽象方法,也可以是非抽象方法
9:抽象类的小问题
A:一个类如果没有抽象方法,可不可以定义为抽象类?如果可以,有什么意义?
B:abstract不能和哪些关键字共存
答:
A:可以,1)为子类提供一个公共的类型
2)封装子类中重复内容(成员变量和成员方法)
B:private,final,static
10:接口的概述及其特点?
答:
接口:体现的是事务的扩展性功能(额外功能,后天学习等)
特点:不能实例化,可以通过子类实现类去实现她的功能
接口的实现类是接口没有意义,有不能实例化
11:接口的成员特点?
答:
抽象类的成员特点:
成员变量:接口的成员变量是一个常量,默认被public static final修饰
构造方法:接口没有构造方法
成员方法:成员方法必须是抽象方法,默认被public abstract修饰
12:抽象类和接口的区别?
答:
1)接口是公开的(public)的,里面不能有私有的成员,是用于让别人去使用的,实现接口一定要实现接口定义的所有抽象方法
抽象类可以有私有方法或私有变量,实现抽象类可有选择的去重写需要用到的方法,但得重写所有的抽象方法
2)抽象类在Java中体现的是一种继承关系,一个类只能使用一次继承关系
一个类却可以实现多个类(多继承)
3)抽象类可以有自己的数据成员,也可以有非抽象方法
接口中的成员变量是静态的常量,且只能有抽象方法
4)抽象类表现的是"is a"的关系
接口变现的是"like a "的关系
13:编程题:
老师和学生案例,加入抽烟的额外功能 (自己给定成员,测试即可!)
//具有抽烟功能的接口
package org.westos.继承与接口的综合练习;
interface Smoke {
void smoke();
}
package org.westos.继承与接口的综合练习;
public abstract class Person {
private String name;
private String school;
int age;
public Person() {
super();
// TODO Auto-generated constructor stub
}
public Person(String name, String school, int age) {
this.name = name;
this.school = school;
this.age = age;
}
/**
* @return the name
*/
public String getName() {
return name;
}
/**
* @param name the name to set
*/
public void setName(String name) {
this.name = name;
}
/**
* @return the school
*/
public String getSchool() {
return school;
}
/**
* @param school the school to set
*/
public void setSchool(String school) {
this.school = school;
}
/**
* @return the age
*/
public int getAge() {
return age;
}
/**
* @param age the age to set
*/
public void setAge(int age) {
this.age = age;
}
public abstract void eat();
public abstract void by();
public void soccer() {
System.out.println("老师与学生一起踢球才能打成一片");
}
}
package org.westos.继承与接口的综合练习;
public abstract class Person {
private String name;
private String school;
int age;
public Person() {
super();
// TODO Auto-generated constructor stub
}
public Person(String name, String school, int age) {
this.name = name;
this.school = school;
this.age = age;
}
/**
* @return the name
*/
public String getName() {
return name;
}
/**
* @param name the name to set
*/
public void setName(String name) {
this.name = name;
}
/**
* @return the school
*/
public String getSchool() {
return school;
}
/**
* @param school the school to set
*/
public void setSchool(String school) {
this.school = school;
}
/**
* @return the age
*/
public int getAge() {
return age;
}
/**
* @param age the age to set
*/
public void setAge(int age) {
this.age = age;
}
public abstract void eat();
public abstract void by();
public void soccer() {
System.out.println("老师与学生一起踢球才能打成一片");
}
}
package org.westos.继承与接口的综合练习;
//老师类
public class Student extends Person{
public Student() {
super();
// TODO Auto-generated constructor stub
}
public Student(String name, String school, int age) {
super(name, school, age);
// TODO Auto-generated constructor stub
}
public void eat() {
System.out.println("学生中午在学校吃饭");
}
public void by() {
System.out.println("学生坐高铁上学");
}
public void soccer1() {
System.out.println("西邮杯电院3:0大胜教职工");
}
}
//学生类
package org.westos.继承与接口的综合练习;
public class Student extends Person{
public Student() {
super();
// TODO Auto-generated constructor stub
}
public Student(String name, String school, int age) {
super(name, school, age);
// TODO Auto-generated constructor stub
}
public void eat() {
System.out.println("学生中午在学校吃饭");
}
public void by() {
System.out.println("学生坐高铁上学");
}
public void soccer1() {
System.out.println("西邮杯电院3:0大胜教职工");
}
}
//抽烟老师类
package org.westos.继承与接口的综合练习;
public class SmokeTeacher extends Teacher implements Smoke {
public SmokeTeacher() {
super();
// TODO Auto-generated constructor stub
}
public SmokeTeacher(String name, String school, int age) {
super(name, school, age);
// TODO Auto-generated constructor stub
}
public void smoke() {
System.out.println("老师说只抽烟不行,晚上旭日皇家大酒店吃饭");
}
}
//抽学生类
package org.westos.继承与接口的综合练习;
public class SmokeStudent extends Student {
public SmokeStudent() {
super();
// TODO Auto-generated constructor stub
}
public SmokeStudent(String name, String school, int age) {
super(name, school, age);
// TODO Auto-generated constructor stub
}
/*public void smoke() {
System.out.println("学生说老师别生气,咱这是友谊赛,来抽烟");
}*/
}
//测试类
package org.westos.继承与接口的综合练习;
public class PersonDemo {
public static void main(String[] args) {
SmokeStudent ss=new SmokeStudent("罗哥","西邮",33);
System.out.println(ss.getName()+"--"+ss.getSchool()+"--"+ss.getAge());
ss.eat();
ss.by();
SmokeTeacher st=new SmokeTeacher("齐祖","西邮",46);
System.out.println(st.getName()+"--"+st.getSchool()+"--"+st.getAge());
st.eat();
st.by();
st.soccer();
System.out.println("----------");
ss.soccer1();
st.soccer2();
ss.smoke();
st.smoke();
}
}
14: 代码块是什么?代码块的分类和各自特点?
答 :代码块:用{}括起来的代码
局部代码块:在main函数中给变量限定她的生命周期
构造代码块:在一个类的成员位置,可以将多个构造方法中相同的代码放在构造代码块中,对对象进行初始化
构造代码块在构造方法执行前先执行
静态代码块:在一个类的成员位置,是静态的,对类进行初始化
静态代码块只能执行一次
15 静态代码块,构造代码块,构造方法的执行流程?
答:优先级:静态代码块>构造代码块>构造方法
16:继承的好处
答:提高代码的复用性,他是多态的前提
17:Java中继承的特点
答:1)子类继承父类,继承了父类所有的东西(成员变量,成员方法,包括私有),但子类不能直接访问父类的私有,必须通过父类公共的访问间接的去访问私有
2)类只支持单继承,不支持多继承,但可以多层继承
接口支持多继承
3)类与类之间是继承关系,类与接口之间是实现关系
18:Java中继承的注意事项?以及我们什么时候使用继承?
答:注意事项:
1)构造方法不能被继承,可以通过super关键字去访问
2)子类不能直接访问父类的私有,只能通过父类公共的访问去间接的访问私有
继承体现的是一种"is a"关系:即A是B的一种或B是A的一种,这时使用继承
19:面试题:
方法重写和方法重载的区别?
Overload
Override
答:
方法重写:1)方法名,参数类型,返回值类型必须全部相同
2)发生在继承类中
方法重载:
1)方法名相同,参数类型或个数不同
2)发生在一个类中
20 下列有关类、对象和实例的叙述,正确的是哪一项?(D)
A.类就是对象,对象就是类,实例是对象的另一个名称,三者没有差别
B.对象是类的抽象,类是对象的具体化,实例是对象的另一个名称
C.类是对象的抽象,对象是类的具体化,实例是类的另一个名称
D.类是对象的抽象,对象是类的具体化,实例是对象的另一个名称
21 下列有关抽象类的叙述正确的是哪项?(C)
A.抽象类中一定含有抽象方法
B.抽象类既能被实例化也能被继承
C.抽象类的声明必须包含abstract关键字
D.抽象类中不能有构造方法
22 下列有关接口的叙述错误的是哪项?(D)
A.接口中只能包含抽象方法和常量
B.一个类可以实现多个接口
C.类实现接口时必须实现其中的方法
D.接口不能被继承
23 下列关于类的继承的描述,正确的有( B C D)
A. 一个类可以同时继承多个父类
B. 一个类可以具有多个子类
C. 子类会自动拥有父类所有的方法
D. 一个类继承另一个类需要使用 extends 关键字
24 下列关于构造函数的说法正确的是( A B D )
A. 方法名必须与类名相同
B. 使用new关键字创建对象时,java虚拟机会自动调用构造函数
C. 我们在定义一个类时,必须要声明至少一个构造函数
D. 构造函数中不能使用return语句(这个是错的,可以rutrun;)
25. 关于继承, 以下说法正确的是: (A)
A.Java中只支持单继承, 一个类只能继承一个类, 但是可以有多个子类
B.一个类如果没有自己写无参构造方法, 那么子类将无法继承
C.子类可以当父类用, 父类不可以当子类用
D. 子类重写父类方法时访问权限不能更低
26 运行以下的main()方法,结果是?(A)
1 public static void main(String[] args)
2 {
3 String myString;
4 int x = 100;
5
6 if (x < 100) myString = "x is less than 100";
7 if (x > 100) myString = "x is greater than 100";
8 System.out.printl(myString.length());
9 }
A. 编译时报出错误提示信息“变量myString没有被初始化”
B. 编译通过
C. 编译未能通过。但如果变量myString在第8行前的代码中被初始化,代码可以编译通过,运行时可以输出字符串myString的长度
D. 以上都不对
27 :博客自己总结知识点
答:
1)字符final:表示最终,终态(不能被更改的意思)
修饰类,该类不能被继承;
修饰成员方法,该方法不能被重写;
修饰成员变量,该变量初始化后是一个常量;
常量类别:
字面值常量;
自定义常量(final修饰的)public final int a=12;
2)final不仅可以修饰基本数据类型,还可以引用类型
如果final修饰的是一个基本数据类型:基本数据类型的值不能再改变了...
如果final修饰的是一个引用类型数据:引用类型的地址值不能再改变了,但是堆内存中的成员变量的值可以改变;
final的初始化时机:
1)被final只能被赋值一次(final int a = 10 )
final int a ;
在使用之前进行初始化,赋值(在构造方法之前赋值) (非静态的...);
2:final关键字的面试题?答: 面试题:final,finally,finalize的区别?
字符final:表示最终,终态(不能被更改的意思)
修饰类,该类不能被继承;
修饰成员方法,该方法不能被重写;
修饰成员变量,该变量初始化后是一个常量;
常量类别:
字面值常量;
自定义常量(final修饰的)public final int a=12;
3:多态是什么,前提是什么?
答:
多态:在同一时刻,体现出来的不同状态.
多态的前提:1)必须有继承
2)必须有方法重写
3)必须有父类引用指向子类对象(向上转型)
4:多态中成员访问的特点?
答:1)成员变量:编译看左,运行看左边
2)成员方法(静态的):编译看左,运行看右边
3)构造方法:子类和父类的构造方法都是对对象进行初始化的
4)静态成员方法:编译看左运行也看左(静态方法跟类有关系算不上方法重写)
5:多态的好处及弊端?如何解决多态的弊端?
答:
多态好处:1)提高代码的复用性,继承体现
2)提高代码的扩展性,多态体现(父类的引用指向子类对象)
多态弊端:不能访问子类特有功能
解决:向下转型,将父类的引用强制转换成子类引用
6:什么是向上转型?什么是向下转型?
答:向上转型:子类引用的对象指向父类类型
向下转型:父类引用的对象指向子类类型
7:抽象类概述及其特点?
答: 抽象类的概念:
针对一个事物,比如:动物类---->总体概括,之前定一个具体的动物(---->必须给他的某个功能只是声明即可),只有,猫或者狗等等这些才是具体事物
Java中,如果一个类中有一个方法声明(抽象方法)抽象功能,那么这个类定义为抽象类
特点:抽象类不能实例化
抽象类:1)如果一个类中有抽象方法,那么这个类必须是抽象类
2)抽象类中不一定有抽象方法
抽象类的子类:
1)抽象类的子类是抽象类没有意义,不能实例化(不能创建对象)
2)子类是具体类,必须实现父类的抽象功能
8:抽象类成员特点?
答:
成员变量:可以是变量也可以是常量
构造方法:可以有无参构造,也可以有有参构造;都是对对象进行初始化
成员方法:可以是抽象方法,也可以是非抽象方法
9:抽象类的小问题
A:一个类如果没有抽象方法,可不可以定义为抽象类?如果可以,有什么意义?
B:abstract不能和哪些关键字共存
答:
A:可以,1)为子类提供一个公共的类型
2)封装子类中重复内容(成员变量和成员方法)
B:private,final,static
10:接口的概述及其特点?
答:
接口:体现的是事务的扩展性功能(额外功能,后天学习等)
特点:不能实例化,可以通过子类实现类去实现她的功能
接口的实现类是接口没有意义,有不能实例化
11:接口的成员特点?
答:
抽象类的成员特点:
成员变量:接口的成员变量是一个常量,默认被public static final修饰
构造方法:接口没有构造方法
成员方法:成员方法必须是抽象方法,默认被public abstract修饰
12:抽象类和接口的区别?
答:
1)接口是公开的(public)的,里面不能有私有的成员,是用于让别人去使用的,实现接口一定要实现接口定义的所有抽象方法
抽象类可以有私有方法或私有变量,实现抽象类可有选择的去重写需要用到的方法,但得重写所有的抽象方法
2)抽象类在Java中体现的是一种继承关系,一个类只能使用一次继承关系
一个类却可以实现多个类(多继承)
3)抽象类可以有自己的数据成员,也可以有非抽象方法
接口中的成员变量是静态的常量,且只能有抽象方法
4)抽象类表现的是"is a"的关系
接口变现的是"like a "的关系
13:编程题:
老师和学生案例,加入抽烟的额外功能 (自己给定成员,测试即可!)
//具有抽烟功能的接口
package org.westos.继承与接口的综合练习;
interface Smoke {
void smoke();
}
package org.westos.继承与接口的综合练习;
public abstract class Person {
private String name;
private String school;
int age;
public Person() {
super();
// TODO Auto-generated constructor stub
}
public Person(String name, String school, int age) {
this.name = name;
this.school = school;
this.age = age;
}
/**
* @return the name
*/
public String getName() {
return name;
}
/**
* @param name the name to set
*/
public void setName(String name) {
this.name = name;
}
/**
* @return the school
*/
public String getSchool() {
return school;
}
/**
* @param school the school to set
*/
public void setSchool(String school) {
this.school = school;
}
/**
* @return the age
*/
public int getAge() {
return age;
}
/**
* @param age the age to set
*/
public void setAge(int age) {
this.age = age;
}
public abstract void eat();
public abstract void by();
public void soccer() {
System.out.println("老师与学生一起踢球才能打成一片");
}
}
package org.westos.继承与接口的综合练习;
public abstract class Person {
private String name;
private String school;
int age;
public Person() {
super();
// TODO Auto-generated constructor stub
}
public Person(String name, String school, int age) {
this.name = name;
this.school = school;
this.age = age;
}
/**
* @return the name
*/
public String getName() {
return name;
}
/**
* @param name the name to set
*/
public void setName(String name) {
this.name = name;
}
/**
* @return the school
*/
public String getSchool() {
return school;
}
/**
* @param school the school to set
*/
public void setSchool(String school) {
this.school = school;
}
/**
* @return the age
*/
public int getAge() {
return age;
}
/**
* @param age the age to set
*/
public void setAge(int age) {
this.age = age;
}
public abstract void eat();
public abstract void by();
public void soccer() {
System.out.println("老师与学生一起踢球才能打成一片");
}
}
package org.westos.继承与接口的综合练习;
//老师类
public class Student extends Person{
public Student() {
super();
// TODO Auto-generated constructor stub
}
public Student(String name, String school, int age) {
super(name, school, age);
// TODO Auto-generated constructor stub
}
public void eat() {
System.out.println("学生中午在学校吃饭");
}
public void by() {
System.out.println("学生坐高铁上学");
}
public void soccer1() {
System.out.println("西邮杯电院3:0大胜教职工");
}
}
//学生类
package org.westos.继承与接口的综合练习;
public class Student extends Person{
public Student() {
super();
// TODO Auto-generated constructor stub
}
public Student(String name, String school, int age) {
super(name, school, age);
// TODO Auto-generated constructor stub
}
public void eat() {
System.out.println("学生中午在学校吃饭");
}
public void by() {
System.out.println("学生坐高铁上学");
}
public void soccer1() {
System.out.println("西邮杯电院3:0大胜教职工");
}
}
//抽烟老师类
package org.westos.继承与接口的综合练习;
public class SmokeTeacher extends Teacher implements Smoke {
public SmokeTeacher() {
super();
// TODO Auto-generated constructor stub
}
public SmokeTeacher(String name, String school, int age) {
super(name, school, age);
// TODO Auto-generated constructor stub
}
public void smoke() {
System.out.println("老师说只抽烟不行,晚上旭日皇家大酒店吃饭");
}
}
//抽学生类
package org.westos.继承与接口的综合练习;
public class SmokeStudent extends Student {
public SmokeStudent() {
super();
// TODO Auto-generated constructor stub
}
public SmokeStudent(String name, String school, int age) {
super(name, school, age);
// TODO Auto-generated constructor stub
}
/*public void smoke() {
System.out.println("学生说老师别生气,咱这是友谊赛,来抽烟");
}*/
}
//测试类
package org.westos.继承与接口的综合练习;
public class PersonDemo {
public static void main(String[] args) {
SmokeStudent ss=new SmokeStudent("罗哥","西邮",33);
System.out.println(ss.getName()+"--"+ss.getSchool()+"--"+ss.getAge());
ss.eat();
ss.by();
SmokeTeacher st=new SmokeTeacher("齐祖","西邮",46);
System.out.println(st.getName()+"--"+st.getSchool()+"--"+st.getAge());
st.eat();
st.by();
st.soccer();
System.out.println("----------");
ss.soccer1();
st.soccer2();
ss.smoke();
st.smoke();
}
}
14: 代码块是什么?代码块的分类和各自特点?
答 :代码块:用{}括起来的代码
局部代码块:在main函数中给变量限定她的生命周期
构造代码块:在一个类的成员位置,可以将多个构造方法中相同的代码放在构造代码块中,对对象进行初始化
构造代码块在构造方法执行前先执行
静态代码块:在一个类的成员位置,是静态的,对类进行初始化
静态代码块只能执行一次
15 静态代码块,构造代码块,构造方法的执行流程?
答:优先级:静态代码块>构造代码块>构造方法
16:继承的好处
答:提高代码的复用性,他是多态的前提
17:Java中继承的特点
答:1)子类继承父类,继承了父类所有的东西(成员变量,成员方法,包括私有),但子类不能直接访问父类的私有,必须通过父类公共的访问间接的去访问私有
2)类只支持单继承,不支持多继承,但可以多层继承
接口支持多继承
3)类与类之间是继承关系,类与接口之间是实现关系
18:Java中继承的注意事项?以及我们什么时候使用继承?
答:注意事项:
1)构造方法不能被继承,可以通过super关键字去访问
2)子类不能直接访问父类的私有,只能通过父类公共的访问去间接的访问私有
继承体现的是一种"is a"关系:即A是B的一种或B是A的一种,这时使用继承
19:面试题:
方法重写和方法重载的区别?
Overload
Override
答:
方法重写:1)方法名,参数类型,返回值类型必须全部相同
2)发生在继承类中
方法重载:
1)方法名相同,参数类型或个数不同
2)发生在一个类中
20 下列有关类、对象和实例的叙述,正确的是哪一项?(D)
A.类就是对象,对象就是类,实例是对象的另一个名称,三者没有差别
B.对象是类的抽象,类是对象的具体化,实例是对象的另一个名称
C.类是对象的抽象,对象是类的具体化,实例是类的另一个名称
D.类是对象的抽象,对象是类的具体化,实例是对象的另一个名称
21 下列有关抽象类的叙述正确的是哪项?(C)
A.抽象类中一定含有抽象方法
B.抽象类既能被实例化也能被继承
C.抽象类的声明必须包含abstract关键字
D.抽象类中不能有构造方法
22 下列有关接口的叙述错误的是哪项?(D)
A.接口中只能包含抽象方法和常量
B.一个类可以实现多个接口
C.类实现接口时必须实现其中的方法
D.接口不能被继承
23 下列关于类的继承的描述,正确的有( B C D)
A. 一个类可以同时继承多个父类
B. 一个类可以具有多个子类
C. 子类会自动拥有父类所有的方法
D. 一个类继承另一个类需要使用 extends 关键字
24 下列关于构造函数的说法正确的是( A B D )
A. 方法名必须与类名相同
B. 使用new关键字创建对象时,java虚拟机会自动调用构造函数
C. 我们在定义一个类时,必须要声明至少一个构造函数
D. 构造函数中不能使用return语句(这个是错的,可以rutrun;)
25. 关于继承, 以下说法正确的是: (A)
A.Java中只支持单继承, 一个类只能继承一个类, 但是可以有多个子类
B.一个类如果没有自己写无参构造方法, 那么子类将无法继承
C.子类可以当父类用, 父类不可以当子类用
D. 子类重写父类方法时访问权限不能更低
26 运行以下的main()方法,结果是?(A)
1 public static void main(String[] args)
2 {
3 String myString;
4 int x = 100;
5
6 if (x < 100) myString = "x is less than 100";
7 if (x > 100) myString = "x is greater than 100";
8 System.out.printl(myString.length());
9 }
A. 编译时报出错误提示信息“变量myString没有被初始化”
B. 编译通过
C. 编译未能通过。但如果变量myString在第8行前的代码中被初始化,代码可以编译通过,运行时可以输出字符串myString的长度
D. 以上都不对
27 :博客自己总结知识点