java格式化输出

package javabase;

public class FormatOutput {
	public static void main(String[] args) {
		for(int i=1;i<=9;i++)
        {
            for(int j=1;j<=i;j++)
            {
                System.out.printf("%d*%d=%-2d ",j,i,j*i);
            }
            System.out.println();
        }
	}
}

代码输出如下
1*1=1  
1*2=2  2*2=4  
1*3=3  2*3=6  3*3=9  
1*4=4  2*4=8  3*4=12 4*4=16 
1*5=5  2*5=10 3*5=15 4*5=20 5*5=25 
1*6=6  2*6=12 3*6=18 4*6=24 5*6=30 6*6=36 
1*7=7  2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49 
1*8=8  2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64 
1*9=9  2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81

这里这里的-2d表示输*出的数字左对齐，并且占用两个字符的宽度（如果不够两位，会在前面用空格补齐），主要是为了使每个输出的三元组（i，j，i*j）的宽度相同，使输出的表格整齐。在这里，"占用两个字符的宽度"指的是输出的数字所占用的字符数量，不超过两个字符的宽度。在Java中，一个整数一般占用一个字节（8位）或四个字节（32位），但是在输出时我们可以通过控制格式，使其只占用指定数量的字符，从而达到对齐的效果。 输出数字右对齐的代码：

public class FormatOutput {
	public static void main(String[] args) {
		for(int i=1;i<=9;i++)
        {
            for(int j=1;j<=i;j++)
            {
                System.out.printf("%d*%d=%2d ",j,i,j*i);
            }
            System.out.println();
        }
	}
}

输出如下

1*1= 1 
1*2= 2 2*2= 4 
1*3= 3 2*3= 6 3*3= 9 
1*4= 4 2*4= 8 3*4=12 4*4=16 
1*5= 5 2*5=10 3*5=15 4*5=20 5*5=25 
1*6= 6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36 
1*7= 7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49 
1*8= 8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64 
1*9= 9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81 

可以看到i*j的结果实现了右对齐，这里3*3= 9里面的9不够两位，会在前面用空格补齐。

模块5 Java面向对象高级特性

继承

java构造方法

构造方法的出现是为了创建对象实例时，就把字段设置为合适的值 构造方法是每个class都有的。 如果父类没有默认的构造方法，子类就必须显式调用super()并给出参数以便让编译器定位到父类的一个合适的构造方法。 子类不会继承父类任何构造方法，子类默认的构造方法是编译器自动生成的。不是继承的。

1、子类不重写构造方法，子类默认拥有一个无参构造方法，但是注意这个构造方法第一行默认执行super()

public class Father {
    //父类第一个无参构造方法
	public Father(){
		System.out.println("子类会调用父类第一个构造方法");
	}
}
public class Son extends Father{}
public class Demo {
    public static void main(String[] args) {
	Son s = new Son();
    }
}
输出：子类会调用父类第一个构造方法
`

2、当子类重写了自己的构造方法，默认第一行还是super()

public class Father {
    //父类第一个无参构造方法
	public Father(){
		System.out.println("子类会调用父类第一个构造方法");
	}
}
public class Son extends Father{
    Son(){};
}
public class Demo {
	public static void main(String[] args) {
		Son s = new Son();
	}
}
输出：子类会调用父类第一个构造方法