JavaSE:7、封装、继承、多态

1、类的封装

将成员变量定义为私有的，从而只能调用方法来访问或修改，不能直接改。

import com.test.*;

public class Main {
    public static  void main(String [] argv)
    {
       //  Person person=new Person();  ERROR  构造函数为私有的，外部无法访问
        Person person=Person.getInstance();
        System.out.println(person.getName());//输出null
    }
}

public class Person {
private String name;
private int age;

private Person(){}
    public static  Person getInstance()
    {
        return new Person();
    }
    public String getName()
    {
        return  name;
    }

}

2、类的继承

使用extends关键字

public class Man extends Person{
    public void test()
    {
        System.out.println("Man");
    }
}

类的继承可以不断向下，但是同时只能继承一个类，同时，标记为final的类不允许被继承

子类继承父类的变量和属性，访问权限允许的话可以直接访问。

package com.test;

public  class Person {
 String name;
 int age;
private String sex;

     Person(){}
     String getsex()
     {
         return sex;
     }

}

package com.test;

public class Man extends Person{
    public void test()
    {
        System.out.println(name+" "+age);
       // System.out.println(sex);  ERROR  无权访问私有成员
        System.out.println(getsex());

    }
}

import com.test.*;

public class Main {
    public static  void main(String [] argv)
    {
     Man man=new Man();
     man.test();
     //null 0
     //null     无法直接访问父类私有成员，但可以通过一些方法来调用
     //生成子类对象时，会将父类的东西初始化
    }
}

若没有写构造函数，那么构造函数和类的权限是一样的，否则就是自已定义的

创建子类对象时会调用子类构造函数，若子类构造函数没调用父类构造函数，则先调用父类构造函数

可以用子类对象创建父类的变量，但本质还是子类的对象，可通过强制类型转换存为子类对象

变量所引用的对象是对应类型或是对应类型的子类，那么instanceof都会返回true，否则返回false。

package com.test;

public  class Person {
 public String name;
 public int age;
private String sex;

     Person(){
      //System.out.println("我是父类无参");
     }
    Person(String n,int a,String s)
    {
         System.out.println("我是父类有参构造");
    }
     String getsex()
     {
         return sex;
     }
}

package com.test;

public class Man extends Person{

    public Man(String s)
   {
        name=s;
   }
    public void test()
    {
        System.out.println(name+" "+age);
       // System.out.println(sex);  ERROR  无权访问私有成员
        System.out.println(getsex());

    }
}

import com.test.*;

public class Main {
    public static  void main(String [] argv)
    {
     Person person=new Man("小明");
     System.out.println(person.name);//小明
        System.out.println(person instanceof Person); //true
     Man man=(Man)person;
     System.out.println(man.name);//小明
        System.out.println(person instanceof Man); //true
    }
}

3、顶层Object类

所有的类都默认继承自Object

此处先了解println、equals这些方法

//将当前对象转换为String的形式，默认情况下格式为 完整类名@十六进制哈希值
    public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

public void println(Object x) {
    String s = String.valueOf(x);   //这里同样会调用对象的toString方法，所以说跟上面效果是一样的
    synchronized (this) {
        print(s);
        newLine();
    }
}

import com.test.*;

public class Main {
    public static  void main(String [] argv)
    {
     Person person=new Man("小明");
     Person person1=new Man("小明");
     System.out.println(person1.equals(person));//false
     System.out.println(person1);//com.test.Man@2f4d3709
    }
}

4、方法的重写

重写object的toString方法，使得println输出不一样

import com.test.*;

public class Main {
    public static  void main(String [] argv)
    {
     Person person=new Man("小明");
     Person person1=new Man("小明");
     System.out.println(person1.equals(person));//false
     System.out.println(person1);//小明 0
    }
}

package com.test;

public  class Person {
 public String name;
 public int age;
private String sex;
     Person(){
      //System.out.println("我是父类无参");
     }
    Person(String n,int a,String s)
    {
         System.out.println("我是父类有参构造");
    }
    public  String toString()
    {
        return name+" "+age;
    }
}

package com.test;

public class Man extends Person{
    public Man(String s)
   {
        name=s;
   }
}

静态方法不可以重写

不希望子类重写某个方法，我们可以在方法前添加final关键字，表示这个方法已经是最终形态

重写的访问权限不能低于父类

5、抽象类

抽象类可以有抽象方法，具体的实现，需要由子类来完成

抽象类无法实例化对象，不能new出来，无论它有没有abstract方法

抽象方法的权限不能为private

6、接口

接口中只能定义访问权限为public抽象方法，只能通过子类实现

接口可以实现多个，用关键字implements

public class Man extends Person implements Study, A, B, C {  //多个接口的实现使用逗号隔开
  
}

静态变量只能是public static final，且必须初始化

静态方法可以写函数体

default关键字可以给方法中写默认行为

package com.test;

public interface Study {
     void study();
     static void  a()
     {
     }
     default void b(){
     }
     public  static final int d=0;
}

 接口可以继承其它接口，但不能继承java类

7、枚举类

package com.test;

public enum State {
    TENNIS,
    FOOTBALL,
    BASKETBALL;
}

package com.test;

public class Person {
 public String name;
 public int age;
private String sex;
 public State state;
 
     public State getState(String s)
     {
         return state;
     }
    public void setStatus(State status) {
        this.state = status;
    }


}

import com.test.*;

public class Main {
    public static  void main(String [] argv)
    {
     Person person=new Person() ;
     person.setStatus(State.BASKETBALL);
     System.out.println(person.state);//BASKETBALL
    }
}