Backgammon] Java基础学习入门（继承）

[Backgammon] Java基础学习入门（继承）

意思就是子承父业，描述类和类之间的关系。

通过extends书写，子类 extends 父类

在java中只支持单继承，导致复用性虽然有但是不高。

public class person{//父类
    String name;
    char gender;
}
public class studeut extends person{//子类继承父类
    public void test(){
        name="张三"；//继承自父类直接使用
            
    }
}

1. super.的用法

super.代指的是当前对象的父类对象。

public class Person{
    String name="张三三";
}
public class Son extends Person{
    String name="张三";
    public Son(){
    	System.out.println(name);//打印结果张三
    	System.out.println(super.naem );//打印结果张三三
    }
}
public class Test{
    public static void main(String[] args){
        Son stu=new Son();
    }
}

• 当子类和父类有同名变量，同名方法时，用super.调用父类方法/变量

2. 方法的重写

在子类继承父类之后，不满足父类提供的方法，子类可以对方法进行重写（覆盖）。

方法重写的前提

• 一定要发生继承关系，子类中的方法和父类中的方法同名

• 参数列表要一摸一样

• 返回值类型要一摸一样

  public class Person { 
  String name; 
  int age; 
  public Person() { 
  System.out.println("父类的空构造器"); 
  }
  public int info(int num) { 
  System.out.println("姓名："+this.name+"，年龄："+this.age); 
  return 1; 
  	} 
  }
  public class Student extends Person{ 
  int id; 
  public Student() { 
  System.out.println("子类的空构造器"); 
  }
  @Override 
  public int info(int num) { 
  System.out.println("姓名："+name+"年龄："+age+"学号："+id); 
  return 1; 
  	} 
  }
  public class Test01 { 
  public static void main(String[] args) { 
  //1:创建一个学生对象 
  Student stu = new Student(); 
  stu.name = "小莉李"; 
  stu.age = 18; 
  stu.id = 1; 
  //2：调用对象的功能 
  stu.info(1); 
  	} 
  }
  

  在子类的同名办法上添加注解@Override,如果方法不报错，那该方法时重写方法

  3. 类型转换

  1.自动转换

  大类型 变量名 = 小类型哦那个值；
  父类型 变量名 子类型对象；
  

  class F{
  }
  class S extends F{ 
  }
  S s = new S();
  System.out.println(s); 
  F f = s;
  System.out.println(f);
  

  2. 强制转换

     小类型 变量名 =（小类型）大类型的值；
     子类型 变量名 = （子类型） 父类型变量；
     

     S s1=(s)f;
     System.out.println(s1);
     F f1=new F();
     S s2=(s)f1;
     

     引用类型的强转一定要格外小心，基本上不要使用、

     4.代码块

     通过一组大括号括起来的内容称之为代码块

     1.初始化块

     定义在类中，方法外的代码块。

     public class Test01{
         public static void main(String[] args)
             F f1 = new F(1);
         	F f2 = new F(2);
     }
     class F{
         {
             System.out.println("F的初始化块")；
         }
         public F(){
         	System.out.println("F的空构造器")
         }
     }
     

     • 对于初始化块而言，每次创建对象之前优先执行初始化块

     • 初始化块的目的就是可以将构造器中重复的代码放到初始化中进行，得带的一定的代码复用的目的。

     • 一半在实际开发中用的比较少的。

       2. 静态代码块

          在初始化块的基础上通过static修饰符就是静态代码

          public class Test01{ 
              public static void main(String[] args) {
                  F f1 = new F(); 
                  F f2 = new F(1); 
                  F.info();
             } 
          }
          class F{
              static{ 
                  System.out.println("F的静态代码块");
            }
              {
                  System.out.println("F的初始化块"); 
            }
              public F() { 
                  System.out.println("F的空构造器"); 
           }
              
          	public F(int age) {
              System.out.println("F的带参构造器");
              }
              public static void info() {
                  System.out.println("F的静态方法");
              } 
          }
          执行结果：
          F的静态代码块 
          F的初始化块
          F的空构造器 
          F的初始化块
          F的带参构造器
          

          • 静态代码优先执行，而且只执行一次。
          • 静态代码块的执行取决于是否调用了当前类中的内容（静态，非静态）