IT十八掌大数据第五天作业
1.文字阐述静态代码块的作用。
静态代码块在类加载时被调用，用于类的初始化，且只被执行一次
2.构造代码块与构造函数的调用顺序如何？和方法的声明位置是否有关？为什么？构造代码块的作用是什么？
构造代码块执行顺序先于构造函数
构造对象时 先调用构造代码块 然后是构造函数
和方法的声明位置无关
构造代码块的作用是对成员变量进行初始化
可以存放多个构造方法的共同代码 ，提升代码的重复性
3.类加载时，是否一定会执行静态代码块？如何手动控制类加载？
类加载时静态代码块不一定被执行
手动控制类加载使用Class.forName("classname"),默认加载类时，执行代码块。
Class.forName(String,boolean initialize,ClassLoader)可以控制加载时是否初始化，并执行静态代码块。
4.定义类Person,Man,Woman形成继承关系。
代码：
/**
* Extends
*/
classPerson {
public String name="Bruce";
public int age=80;
public Person(){
System.out.println("newPerson");
}
public void eat(){
System.out.println("eat");
}
}
classMan extends Person{
public String behaviour ="working";
public Man(){
System.out.println("newMan");
}
public void eat(){
//super.eat();
System.out.println("Maneat");
}
public void ShowMan(String name,int age,String behaviour){
System.out.println("manname is "+name+" , age is "+String.valueOf(age)+",behaviour is "+behaviour);
}
}
classWoman extends Person{
public String behaviour ="Shopping";
public Woman(){
System.out.println("newWoman");
}
public void eat(){
//super.eat();
System.out.println("Womaneat");
}
public void ShowWoman(String name,int age,String behaviour){
System.out.println("Womanname is "+name+" , age is "+String.valueOf(age)+",behaviour is "+behaviour);
}
}
classExtendsTest{
public static void main(String[] args){
Man man=new Man();
Woman woman=new Woman();
man.eat();
man.name="Kal";
man.age=95;
man.ShowMan(man.name,man.age,man.behaviour);
woman.eat();
woman.name="Kistina";
woman.age=100;
woman.ShowWoman(woman.name,woman.age,woman.behaviour);
}
}
执行结果：
Java文件
5.什么是抽象方法？什么是抽象类？抽象类是否有构造函数，是否可以重载？
抽象方法：没有方法体的方法。必须使用abstract修饰。
抽象类：抽象方法只能存在于抽象类中。抽象类也必须要使用abstract修饰。
有抽象方法的一定是抽象类，抽象类不一定有抽象方法
抽象类有构造函数并且可以重载。
6.抽象修饰符有哪些非法组合？并给出合理的解释？
abstract + static 是非法的修饰符组合。
abstract + final 是非法的修饰符组合。
abstract + private是非法的修饰符组合。
被abstract修饰过的方法或类必须要被继承并实现，但被final修饰过的是最终的，不能更改
final修饰过的类或方法不能被继承因此abstract + final是非法的修饰符组合；
被abstract修饰过的方法或类必须要被继承并实现，但被private修饰过的类或方法是私有的，
不能被继承因此abstract + static 是非法的修饰符组合；
被abstract修饰过的方法或类必须要被继承并实现并且包含abstract方法的类也必须是抽象类
，因此这个类不能被实例化，但加上static修饰后通过类名就可以创建对象进行实例化，相互
矛盾，因此abstract + static 是非法的修饰符组合
7.super和this作用以及用法以及注意事项？
super : 超类,作用方面类似于this.
super(...): 访问超类的构造函数.只能用在第一行。默认是super();
this是只想对象自身的引用
this：指向对象自身的引用。
this(...)表示的是调用当前类的构造函数.只能用在第一行。默认this();
8.定义接口
1.IWhite
2.IRich
3.IBeanti
4.定义类，实现以上三个接口.(WomenStar)
5.定义土豪类(EarchRicher.marring(...))
05_interface.java
代码：
/**
* 定义接口
*/
interface IWhite{
public static final booleaniswhite=true;
public void IWhite(boolean iswhite);
}
interface IRich{
public static final boolean isrich=true;
public void IRich(boolean isrich);
}
interface IBeanti{
public static final boolean isbeautiful=true;
public void IBeanti(boolean isbeautiful);
}
interface IBFM extends IWhite,IRich,IBeanti{
}
classWomenStar implements IBFM{
public void IWhite(boolean iswhite){
System.out.println("WomenStar white is"+String.valueOf(iswhite));
}
public void IRich(boolean isrich){
System.out.println("WomenStar rich is "+String.valueOf(isrich));
}
public void IBeanti(boolean isbeautiful){
System.out.println("WomenStar beautifulis "+String.valueOf(isbeautiful));
}
public static boolean getIswhite(){
return iswhite;
}
public static boolean getIsrich(){
return isrich;
}
public static boolean getIsbeautiful(){
return isbeautiful;
}
}
classEarchRicher{
public voidmarring(WomenStar woman){
if(woman.getIswhite()&&woman.getIsbeautiful()&&woman.getIsrich())
System.out.println("marringsuccess");
elseSystem.out.println("marring fialed");
}
}
classintefaceTest{
public static void main(String[] args){
WomenStar ws =new WomenStar();
EarchRicher er= new EarchRicher();
ws.IWhite(ws.iswhite);
ws.IRich(ws.isrich);
ws.IBeanti(ws.isbeautiful);
er.marring(ws);
}
}
执行结果：
