java中的组合技术,只需要将一个对象引用置于一个新类之中即可,对于非基本类型的对象,必须将其引用置于新的类中;对于基本类型我们可以直接在类中定义他。
    实例代码——组合技术

    1. class WaterSource{
    2. private String wname;
    3. WaterSource(){
    4. System.out.println("WaterSource");
    5. wname="长白山";
    6. }
    7. @Override
    8. public String toString() {
    9. return wname;
    10. }
    11. }
    12. class SpinkLerSytem {
    13. //基本类型数据,直接定义
    14. private String value1,value2,value3,value4;
    15. private int i;
    16. private float f;
    17. private WaterSource waterSource=new WaterSource();//非基本类型数据
    18. @Override
    19. public String toString() {
    20. return "SpinkLerSytem{" +
    21. "value1='" + value1 + '\'' +
    22. ", value2='" + value2 + '\'' +
    23. ", value3='" + value3 + '\'' +
    24. ", value4='" + value4 + '\'' +
    25. ", i=" + i +
    26. ", f=" + f +
    27. ", waterSource=" + waterSource +
    28. '}';
    29. }
    30. public static void main(String[] args) {
    31. SpinkLerSytem spinkLerSytem = new SpinkLerSytem();
    32. System.out.println(spinkLerSytem);
    33. }
    34. }

    那么我们可以去思考,对于这些数据类型我们都可以在代码中的什么地方进行初始化呢?
    1.在定义对象的地方进行初始化 。
    2.在类的构造器中
    3.在使用对象的时候进行初始化——惰性初始化
    4.实例初始化————?(什么是实例初始化呢?)
    对于上面四种初始化的方式,我们通过下面的代码一一展示
    实例——四种初始化方式

    1. class Soap {
    2. String str;
    3. Soap(){
    4. System.out.println("soap()");
    5. str="Soap====";//构造器初始化
    6. }
    7. @Override
    8. public String toString() {
    9. return str;
    10. }
    11. }
    12. public class Bath {
    13. private String str1="Tom",//1.定义对象时初始化
    14. str2;//2.惰性初始化,先不对str2赋值,
    15. private int i;
    16. private Soap soap;
    17. Bath(){
    18. soap=new Soap();//3.构造器初始化
    19. }
    20. {//4.实例初始化,即在new 出对象的实例后执行的,new 一次执行一次
    21. int i=47;
    22. }
    23. @Override
    24. public String toString() {
    25. if (str2==null)//此处对str2进行判断为空则赋值
    26. str2="Tom2";
    27. return "str1='" + str1 + '\'' +
    28. ", str2='" + str2 + '\'' +
    29. ", i=" + i +
    30. ", soap=" + soap;
    31. }
    32. public static void main(String[] args) {
    33. Bath b = new Bath();
    34. System.out.println(b);
    35. }
    36. }
    37. OutPut:
    38. soap()
    39. str1='Tom', str2='Tom2', i=0, soap=Soap====

    普通代码块和静态代码块的区别:
    静态代码块只执行一次
    普通代码块new 一次执行一次