java的三大特性--封装，继承，多态

用三个类父类，子类，测试类

测试java的三大特性：封装，继承，多态：

 

父类：

package oop;

/** 面向对象的三大特性：封装，继承，多态 */
public class Character {
 /*
  * 封装：万物皆对象，我们把这些对象封装起来组成数据类型，那数据类型包括 属性和方法
  */

 /*
  * 类中的属性隐藏，提供公开的方法 修辞符 类型 属性名称; (可选：将赋值)
  */
 private String name;

 private int age;

 private final long ID;

 /* 类需要实例化，就提供构造方法 */
 public Character(long ID) {
  this.ID = ID;
  System.out.println("父类的构造方法，有参的");
 }

 /* 无参的构造函数，自己不定义系统也会定义一个无参无实现的工作函数 */
 public Character() {
  this.ID = 1000009489;
  System.out.println("父类的构造方法，无参的");
 }
 
 static{
  System.out.println("父类的静态代码块");
 }
 
 {
  System.out.println("父类的实例代码块");
 }

 /* 为隐藏的属性提供公开的方法seter和getter */
 public int getAge() {
  return age;
 }

 public void setAge(int age) {
  this.age = age;
 }

 public long getID() {
  return ID;
 }

 public String getName() {
  return name;
 }

 public void setName(String name) {
  this.name = name;
 }

 /*
  * 定义方法 修辞符 返回类型 方法名(参数列表){} 参数：类型 参数名
  */

 public void method1() {
  System.out.println("父类的method1()方法");
 }

 private void method2(int num, String name) {
  System.out.println("父类的method2(int num, String name)方法");
 }

 public void method3(String name) {
  System.out.println("父类的method3(String name)方法");
 }

 /*
  * 方法的重载： 同一个类，同名，不同参数
  */
 public void m1() {
  System.out.println("父类的m1()方法");
 }

 /*
  * public boolean m1(){ error }
  */

 /*
  * private void m1(){ error
  *  }
  */
 public void m1(String name) {
  System.out.println("父类的m1(String name)方法");
 }

 /*public boolean m1(String name) {
  error
 }*/

 public void m1(String name, int age) {
  System.out.println("父类的m1(String name, int age)方法");
 }

 public boolean m1(int age) {
  System.out.println("父类的m1(int age)方法");
  return true;
 }

}

 

子类：

package oop;

/**
 * 继承：子类继承于父类，继承了方法和属性 语法： 修辞符 class 子类名 extends 父类名{}
 */
public class SendCharacter extends Character {
 private String sendName;

 public String getSendName() {
  return sendName;
 }
 
 static{
  System.out.println("子类的静态代码块");
 }
 
 {
  System.out.println("子类是实例代码块");
 }

 public void setSendName(String sendName) {
  this.sendName = sendName;
 }

 /* 子类的构造方法一定要调用父类的构造方法 */
 public SendCharacter(long ID) {
  super(ID);// 调用父类的构造方法
  System.out.println("子类的有参构造方法");
 }

 public SendCharacter() {
  super();// 调用父类的构造方法
  System.out.println("子类的无参构造方法");
 }
 
 /*方法的覆盖：
  * 1.同没
  * 2.同参
  * 3.父子类之间
  * 4.子类的修辞符不能比父类的更封闭
  * 5.子类抛出的异常不能比父类更宽泛
  * */
 
 public void m1(){
  System.out.println("子类覆盖的m1()方法");
 }
 
 private void method2(int num, String name) {
  System.out.println("子类覆盖的method2(int num, String name)方法");
 }
 
 public void method3(String name) {
  System.out.println("子类覆盖的method3(String name)方法");
 }
 
 /**自己写的方法：*/
 public void subM1(){
  System.out.println("子类自己的subM1()方法");
 }

}

测试类：

 

package oop;

public class Test {

 public static void main(String[] args) {
  System.out.println("main of start");
  //父类对象
  Character c=new Character();
  //父类对象，只能调用父类的方法
  c.m1();
  c.m1(10);
  
  
  //子类对象，父类，子类的方法都能调用
  SendCharacter sc=new SendCharacter();
  sc.subM1();
  
  //多态:--把子类对象当父类来看
  Character  cs=new SendCharacter();
  cs.m1();
  cs.m1(20);
  //cs.subM1();//error
  
  /*
   *
   * 1.如果我们把子类的对象当成父类来看，那我们就只能访问
   * 父类中已有的方法和属性
   * 2.如果子类把父类的方法覆盖了，再把子类当成父类来看，去
   * 调用方法调用的是覆盖后的方法
   *
   * 主观认为----------客观存在
   *
   * 编译时类型(编译器)--------运行时类型(JVM)
   * */
  
  System.out.println("main of end");
 }
 
 //运行结果如下：
 
 /*main of start
 父类的静态代码块
 父类的实例代码块
 父类的构造方法，无参的
 父类的m1()方法
 父类的m1(int age)方法
 子类的静态代码块
 父类的实例代码块
 父类的构造方法，无参的
 子类是实例代码块
 子类的无参构造方法
 子类自己的subM1()方法
 父类的实例代码块
 父类的构造方法，无参的
 子类是实例代码块
 子类的无参构造方法
 子类覆盖的m1()方法
 父类的m1(int age)方法
 main of end*/

}