1.文字阐述静态代码块的作用。
2.构造代码块与构造函数的调用顺序如何？和方法的声明位置是否有关？为什么？构造代码块的作用是什么？
3.类加载时，是否一定会执行静态代码块？如何手动控制类加载？
4.定义类Person,Man,Woman形成继承关系。
5.什么是抽象方法？什么是抽象类？抽象类是否有构造函数，是否可以重载？
6.抽象修饰符有哪些非法组合？并给出合理的解释？
7.super和this作用以及用法以及注意事项？
8.定义接口
1.IWhite
2.IRich
3.IBeanti
4.定义类，实现以上三个接口.(WomenStar)
5.定义土豪类(EarchRicher.marring(...))
-----------------------------------------------------
1.文字阐述静态代码块的作用。
答：静态代码块的形式为static{ },在类中的位置与类的成员变量，方法同级，随着类的加载而加载到静态方法区当中，并且只执行一次，静态代码块先于构造函数和构造代码块的执行，
静态代码块的作用是为了给类做初始化动作，使类在创建对象之前已经完成初始化。
2.构造代码块与构造函数的调用顺序如何？和方法的声明位置是否有关？为什么？构造代码块的作用是什么？
答：在创建对象时，构造代码块先于构造函数执行，与方法的声明位置无关，因为在创建对象时，JVM会先调用构造代码块给对象进行统一初始化，然后才调用构造函数初始化对象的特有属性。
构造代码块的作用是为了给不同对象进行统一初始化，初始化不同对象的共性属性。
3.类加载时，是否一定会执行静态代码块？如何手动控制类加载？
答：类加载时不一定会执行静态代码块，我们可以通过Class类中的方法手动控制类加载，
具体可以通过Class类中的forName（String classname,boolean initialize,ClassLoader loader)方法
来控制类加载时是否执行静态代码块，当initialized的参数为为false时，手动加载类时就不会执行静态代码块
只有当initialized的参数为true时，且以前未被初始化时，才会调用静态代码块初始化该类。
4.定义类Person,Man,Woman形成继承关系。
class Person
{
public String name;
public int age;
public void eat()
{
System.out.println("Person具有吃饭的功能！");
}
}
class Man extends Person
{
public void eat()
{
System.out.println("男人具有吃饭的功能！");
}
}
class Woman extends Person
{
public void eat()
{
System.out.println("女人具有吃饭的功能！");
}
}
class ExtendsDemo
{
public static void main(String[] args)
{
Person person = new Person();
Man man = new Man();
Woman woman = new Woman();
person.eat();
man.eat();
woman.eat();
}
}5.什么是抽象方法？什么是抽象类？抽象类是否有构造函数，是否可以重载？
答：1）由abstract关键字修饰的没有功能主体的方法称为抽象方法，格式为： abstract [修饰符] [返回值类型] method();
抽象方法必须在抽象类中定义，且抽象类的非抽象子类必须实现其中所有的抽象方法。
2）抽象类是由abstract关键字修饰的类并且该类不能被直接创建对象，抽象类内部可以有非抽象方法，并且该非抽象方法可以调用所在抽象类
内部的抽象方法，因为抽象类不能被直接创建对象来调用该非抽象方法，自然也不会有对象直接调用到其中的抽象方法，符合抽象规则。
3）抽象类内部有构造函数，也可以重载，该抽象类的非抽象子类的构造函数第一行默认会隐式调用父类空参数的构造函数，或者手动调用父类
重载的带参的构造函数，方法是通过super(args1,args2,...)显式调用。
6.抽象修饰符有哪些非法组合？并给出合理的解释？
答：abstract + static : 非法组合的修饰符
|----解释：abstract修饰方法时，所处类为抽象类，抽象方法没有功能主体，不能通过直接创建对象调用，关闭了调用入口，而static修饰方法，可以直接通过类名调用该方法，所以矛盾。
abstract + final ： 非法组合的修饰符
|----解释：abstract修饰方法时，所处类为抽象类，需要其非抽象子类重写该方法具体实现，而final关键字修饰方法后，子类无法对该方法进行重写，所以矛盾。
abstract + private ： 非法组合的修饰符
|----解释：abstract修饰方法时，所处类为抽象类，需要其非抽象子类重写该方法具体实现，而private关键字修饰该方法后，子类无法访问到该方法，自然也就无法重写，所以矛盾。
7.super和this作用以及用法以及注意事项？
答：1） super的对父类的引用，可以调用父类的成员变量和一般方法以及构造函数。
|---- 用法： super.属性或者方法，super(args1,...)
this是对本类对象的引用。可以调用本类的成员变量和一般方法以及构造函数。
|---- 用法： this.属性或者方法，this(args1,...)
2）注意事项：
1，子类在构造函数中调用父类的构造函数初始化时，必须将super（args1,...）调用放在构造函数的第一行，先进行父类初始化操作.
2，类在构造函数中调用本类其他构造函数初始化时，必须将this（args2,...）调用放在构造函数第一行，先进行初始化。
3,子类在重载构造函数时不能同时通过super(args1,...)和this(args2,...)同时调用父类和本类的构造函数进行初始化。
8.定义接口
1.IWhite
2.IRich
3.IBeanti
4.定义类，实现以上三个接口.(WomenStar)
5.定义土豪类(EarchRicher.marring(...))
/**
定义接口：
1.IWhite
2.IRich
3.IBeanti
4.定义类，实现以上三个接口.(WomenStar)
5.定义土豪类(EarchRicher.marring(...))
*/
class TuhaoDemo
{
public static void main(String[] args)
{
//在非诚勿扰找到一位白富美
WomenStar wstr = new WomenStar("朱宸慧");
//在非诚勿扰上来一位土豪
Tuhao Tuhao = new Tuhao("王思聪");
//土豪是否找到了妻子。
Tuhao.getMarry(wstr);
}
}
/**
*定义三个接口，给出白富美的特性定义
*/
interface IWhite
{
void skinWhite();
}
interface IRich
{
void walletRich();
}
interface IBeanti
{
void faceBeanti();
}
//实现三个白富美的特性接口，成为真正白富美类
class WomenStar extends Person implements IWhite,IRich,IBeanti
{
public WomenStar(String name)
{
super(name);
}
public void skinWhite()
{
System.out.println("白富美具有皮肤白的特性");
}
public void walletRich()
{
System.out.println("白富美具有钱包鼓的特性");
}
public void faceBeanti()
{
System.out.println("白富美具有");
}
}
//定义一个土豪类，明确征婚需求
class Tuhao extends Person
{
public Tuhao(String name)
{
super(name);
}
public void getMarry(WomenStar wstr)
{
System.out.println("土豪"+this.getName()+"找到了白富美妻子"+wstr.getName()+"!!!");
//这里不能通过this.name获取TuHao的name属性。因为Person类中name被private私有化了，不能被继承过来
//如果Person类的name属性的权限改为protected，这里就可以直接通过this.name访问了。
}
}
//定义一个人类
class Person
{
private String name;
public Person(String name)
{
this.name = name;
}
public void setName(String name)
{
this.name = name;
}
public String getName()
{
return name;
}
}
转载于:https://blog.51cto.com/liubx/1770990
