Java复用类
组合与继承
- 组合：在新的类中产生现有类的对象。
- 继承：按照现有类的类型来创建新类，无需改变现有类的形式，采用现有类的形式并在其中添加新的代码。
组合：
public class TestDemo1 {
public static void main(String[] args) {
A a = new A();
a.f1();
}
}
class A{
public void f1(){
B b = new B("哈登");//组合
b.f2();
System.out.println(b);// 如果不覆写B类中的toString(),那么就会输出b对象的地址
}
}
class B{
private int age;
private String name ;
public B(String name){
this.name = name;
this.age=28;
}
public void f2(){
System.out.println("姓名为:"+name+" ,年龄为:"+age);
}
@Override
public String toString() {
return name;
}
}
打印结果
这里在B类的构造方法中初始化了age的值，如果将this.age=28注释掉，那么年龄为0.
关于初始化
1.类中域为基本类型时，默认自动初始化为0
2.类中域为引用类型时，默认自动初始化为null
初始化位置
1.在定义对象的地方。意味着在调用构造器之前进行初始化
2.在类的构造器中
3.实例初始化
4.延迟初始化（惰性初始化）在使用对象之前
看一下具体代码
public class ChuShiHua {
public static void main(String[] args) {
Student student = new Student("Messi");
System.out.println(student);
}
}
class Student {
//1.在定义对象的地方。意味着在调用构造器之前进行初始化
private String name1="Ronaldo";
private String name2,name3,name4;
//2.在类的构造器中
public Student(String name2){
this.name2 = name2;
}
// 3.实例初始化
{
name3="Alice";
}
// 4.延迟初始化（惰性初始化）在使用对象之前
@Override
public String toString() {
if(name4==null){
name4="Peter";
}
return name1+" "+name2+" "+name3+ " "+ name4;
}
}
继承
class Fu{
public Fu(){
System.out.println("这是父类构造");
}
}
class Son extends Fu{
public Son(){
System.out.println("这是子类构造");
}
}
public class JiCheng {
public static void main(String[] args) {
new Son();
}
}
这里Son类继承了Fu类。关键字是extends.无论如何，父类构造总是先被初始化，然后再初始化子类构造。
子类默认调的是父类的无参构造，如果想要调用父类的有参构造，那么在子类构造的第一句话写上super(..)
class Fu{
int age;
public Fu(){
System.out.println("aaa");
}
public Fu(int age){
this.age = age;
System.out.println("这是父类构造"+this.age);
}
}
class Son extends Fu{
int i;
public Son(int i){
**super(20);**
this.i = i ;
System.out.println("这是子类构造"+ i);
}
}
public class JiCheng {
public static void main(String[] args) {
new Son(10);
}
}
protected关键字
- 对于类的用户而言，是私有的
- 对于其子类或者同一包的类而言，是可以访问的
在F类中定义了一个protected修饰的方法，在Z类中可以访问的。
向上转型
继承的最大用处并不是复用类，而是多态。多态又是基于继承的。
class Instrument{
static void play(Instrument e){
System.out.println("通过向上转型"+e);
}
}
public class Wind extends Instrument{
public static void main(String[] args) {
Wind wind = new Wind();
Instrument.play(wind);
}
}
在play（）方法中，将Wind对象传入到父类Instrument的play（）方法中，照样能够打印出Wind对象。用父类的引用去接收子类的对象，其指向的是子类对象。
final关键字
final所描述的对象是无法改变的。主要用在类，方法，数据中。
数据
告知编译器这块数据是无法改变的。
1.一个永不改变的编译时常量---减轻了运行时的负担
2.一个运行时被初始化的值，而你并不需要它被改变
3.一个即是static 又是 final 的数据描述的是只占据一块不能改变的存储空间
4.当final作用在基本类型的时候，指的是数值无法改变。当fianl作用于对象的引用时，指的是对象的引用不变，但对象本身还是可以改变的。
class FinalData{
int num = 1;
public final int age1 =20;
/*
* 1.用static final 修饰的变量应该字母全部大写
* 2.用public可以无限制被访问
* 3.static：强调只有一份
* 4.final: 说明它是一个常量
*
* */
public static final int AGE = 10;
}
public class FinalTest {
public static void main(String[] args) {
FinalData fd = new FinalData();
System.out.println(fd.age1);//输出20
// fd.age1=30; 由于age是final所修饰的基本类型，数值不能被改变。
final FinalData fdFinal = new FinalData();
fdFinal.num=30;
System.out.println(fdFinal.num);//打印30
//无法编译，因为fdFinal的引用是不能被改变的
// fdFinal = new FinalData();
}
}
final参数
class FinalData{
public void fun(final int i){
// i++;无法编译，因为i是final类型，值无法改变
}
public void fun2(final FinalData f){
f.fun(1);
// f = new FinalData(); 无法编译，因为f的引用不可变
}
}
public class FinalTest {
public static void main(String[] args) {
}
}
final方法
作用：
- 把方法锁定，防止任何继承类修改它的含义
- 效率
类中所以的private方法都是final类型的，由于无法取用private方法，所以也就无法覆盖它。
class GrandFather{
private final void fun(){
System.out.println("11");
}
}
class Father extends GrandFather{
private final void fun(){
System.out.println("22");
}
}
class Son extends Father{
public final void fun(){
System.out.println("33");
}
}
public class FinalMethodTest {
public static void main(String[] args) {
Son s = new Son();
s.fun();//打印33
GrandFather f = s;
//f.fun(); 无法编译
}
}
类内所有 private 方法都自动成为 final。由于我们不能访问一个 private 方法，所以它绝对不会被其他方
法覆盖（若强行这样做，编译器会给出错误提示）。可为一个 private 方法添加 final 指示符，但却不能为
那个方法提供任何额外的含义。
final类
final类描述的是该类没有子类，无法被继承。
可以看到上面代码报错，无法编译，原因是父类被声明为final类型。
在一个类中如果被声明为final类型，那么该类的方法隐式的都被声明为final类型。
初始化及类的加载
class Fu {
private int age =70;
private String name;
public static String address = "崇明岛";
static {
System.out.println("这是父类的static静态块");
}
public Fu(){
System.out.println("这是父类构造");
}
public void fu(){
System.out.println(age+name+address);
}
}
class Zi extends Fu{
private int age=30 ;
private String name;
public static String address = "海南岛";
static {
System.out.println("这是子类的static静态块");
}
public Zi(){
System.out.println("这是子类构造");
}
public void zi(){
System.out.println(age+name+address);
}
}
public class CSHTest extends Zi{
private int age=10 ;
private String name;
public static String address = "台湾岛";
static {
System.out.println("这是孙类的static静态块");
}
public CSHTest(){
System.out.println("这是孙类构造");
}
public void test(){
System.out.println(age+name+address);
}
public static void main(String[] args) {
CSHTest t = new CSHTest();
t.test();
}
}
首先执行CSHTEST类的main方法，类加载器查找CSHTEST编译后的代码.class，发现其有一个父类Zi,于是加载Zi,发现它又有一个父类，于是再加载Fu，此时，根基类中的static初始化(static修饰符描述的方法只执行一次)，然后是下一个导出类，以此类推。此种方式很重要。因为导出类初始化有可能依赖于父类的初始化。
此时类已经加载完毕了。现在可以创建对象了。首先，对象中的基本类型都被初始化为0，对象的引用都被初始化为null,然后，基类的构造器就被调用，在本例中，是默认调用的，默认调用super()，如果想指定调用有参构造，那么自己写super(Type Args).
总结就是：加载父类的静态块--->加载子类静态块---->加载父类的构造--->加载子类构造
声明
所写内容是《Thinking In Java》读书笔记
