温习Java笔记(5)：构造函数、继承和多态

 
    原来的java书不见了唉，找过一本继续复习之路。
    今天温习构造函数、继承和多态的概念了，原来就是这样，之前用了很多，就是对这些概念早已经模糊，系统学习和回过头来温习是真的非常重要的。 
 
 
    1.构造函数
    构造函数是类中的一种特殊方法，他没有返回值类型，其名称与类名称相同，方法的参数用来传递给有关的成员变量。构造函数的作用是初始化类对象，即为类对象的成员变量赋值。 

    2.对象的创建和使用
    定义了一个类后，就有了这一类对象的原型，它是用户自定义的一种复合数据类型。可以用这个类作为模板去创建该类的一个具体对象，通过构造函数可以实例化一个类对象。格式如下：
类名 对象名 = new 构造函数(实际参数)
访问对象的成员变量和调用对象的成员方法通过圆点操作符(.)实现，如 对象名.变量名、对象名.成员方法

Person.java

public class  Person
... {
 String name;
 char sex;
 int age;
 public Person( String s,char c ,int i) //构造函数
 ...{
  name = s;
  sex = c;
  age = i;
 }

 public String toString()
 ...{
  String s = "姓名：" + name + " 性别：" + sex + "  年龄：" + age ;
  return s ;  
 }

}
 
 
TestPerson.java 
 
 
public class  TestPerson
... {
 public static void main ( String[] args)
 ...{
  Person p1,p2; //定义Person类对象p1,p2
  p1 = new Person("张三",'男',20); //初始化Person类对象p1
  p1.age = 21; //修改对象p1中的变量age的值为21
  
  p2 = new Person("李四",'女',18); //初始化Person类对象p2  
  //调用Person类对象p1的toString()方法，显示结果
  System.out.println(p1.toString());
  System.out.println(p2.toString());
 }

}  
 
 

 

    3.类的继承
    在java程序设计中，已有的类可以是java开发环境提供的一批最基本的程序-类库，用户开发的程序类是继承已有的类，被继承的类成为父类或超类，经继承产生的类成为 子类或派生类。
如果一个子类只允许继承一个父类，成为单继承类，如果允许从多个父类中继承，成为多继承。java语言只支持单继承，单可以通过接口(interface)的方法类实现多继承。子类的直接父类是该子类直接继承的类，而间接父类则两级或两级以上的父类。
    类继承通过关键字extends实现类的继承，其格式如下：
    [修饰符] class [类名] extends 父类名 
    {
         类体；
    } 
    如果类定义中，没有显示关键字extends指明继承自某个类，则默认该类继承继承于Object类 
 

Student.java
 
public class  Student extens Person
... {
 protected int chinese,math;
 public Student()
 ...{}
 // protected修饰符存在则通常要求父类Person本身和它的子类以及同一类包内的其他类才能访问Person的这三个变量成员
 
 //构造函数定义了该类有三个参数的构造函数，分别对继承自父类的3个成员变量name、sex、age和子类增加的2个整数变量
 //chinese和math的赋值，通过继承，则不需要重写Person类，保留了父类的属性和行为，实现了代码重用
 public student( Sting str,char ch,int x,int y,int z)  //构造函数 
 ...{
  name=str;
  sex=ch;
  age=x;
  chinese=y;
  math=z;
 }
 
 public int average()
 ...{
  return ( chinese + math)/2
 }

}  

TestPerson.java

public class  TestStudent
... {
 public class void main (String[] args)
 ...{
  Student s1 = new Student();
  System.out.println("s1" + s1.toString() + ";成绩：" + s1.average());
  Student s2 = new Student("tom",'m',25,88,97); 
  System.out.println("s2" + s2.toString() + ";成绩：" + s2.average()); 
 }


}

  
    构造函数也可以继承，子类无条件的继承父类不含参数的构造函数，当通过子类不含参数的构造函数创建子类对象时，先继承父类不含参数的构造函数，再执行子类不含参数的构造函数。

    同一个类中的构造函数可以重载，重载的构造函数可以通过this()互相调用。如果子类要调用父类的构造函数，则通过super()来实现。 

Student.java
 
public class  Student extens Person
... {
 protected int chinese,math;
 public Student()
 ...{}
 // protected修饰符存在则通常要求父类Person本身和它的子类以及同一类包内的其他类才能访问Person的这三个变量成员
 
 //构造函数定义了该类有三个参数的构造函数，分别对继承自父类的3个成员变量name、sex、age和子类增加的2个整数变量
 //chinese和math的赋值，通过继承，则不需要重写Person类，保留了父类的属性和行为，实现了代码重用
 
 System.out.println("调用子类不含参数的构造函数")
 public student( Sting str,char ch,int x,int y,int z)  //构造函数 
 ...{
  super(str,ch,x);//调用父类构造相当与省略了name=str、sex=ch、age=x
  chinese=y;
  math=z;
 }
 
 public int average()
 ...{
  return ( chinese + math)/2
 }

}  

TestPerson.java

public class  TestStudent
... {
 public class void main (String[] args)
 ...{
  Student s1 = new Student();
  System.out.println("s1" + s1.toString() + ";成绩：" + s1.average());
  Student s2 = new Student("tom",'m',25,88,97); 
  System.out.println("s2" + s2.toString() + ";成绩：" + s2.average()); 
 }


}  

 

    如果父类不允许通过继承所产生的子类访问它的某些成员，那么父类中必须以private方式声明这些成员。
继承性使得子类也继承它不需要的父类的变量和方法，当一个父类成员不合适该子类时，子类可以重新定义它。
子类重新定义从父类继承来的同名变量称为变量的隐藏，即子类的同名变量隐藏了父类的同名变量，这时子类若要引用父类的同名变量，要用super关键字做前缀加圆点操作符引用：
    super.变量名();
    super.方法名();
    这种方法称为方法的覆盖，是java的多态性表现之一。

Student.java
 
public class  Student extens Person
... {
 protected MyDate age ;  //定义了与父类Person中同名的变量age，为MyDate类对象表示出生年月日，而父类中age是整型       //变量，表示年龄,他们是不同类型的变量，这就是变量的隐藏
 protected int chinese,math;
 public Student()
 ...{}


 public student( Sting str, char ch, MyDate mydate, int x, int y,int z)  //构造函数 
 ...{
  name=str;sex=ch;
  age = mydate ;
  chinese=y;
  math=z;
  super.age=2003-age.getYear();
 }
 
 public int average()
 ...{
  return ( chinese + math)/2
 }

 public String toString()
 ...{  
  return super.toString() + " 生日：" + age.toString() + "；成绩" + average();  
 }
 /**//*
 定义了与父类方法完全一样的方法：public String toString()，方法体不同，这成为方法的覆盖，实际上，父类Person中的方法toString就是覆盖的其父类Object中的同名方法，因此该方法的覆盖必须与Object类中toString()方法的方法完全一样，否则程序编译会出错
 通过super方法调用父类被覆盖的同名方法toString()；age.toString()调用MyDate类的方法，通过加号将这些字符连接成一个字符串并返回
 */
}  

TestPerson.java

public class  TestStudent
... {
 public class void main (String[] args)
 ...{
  Student s1 = new Student();
  System.out.println("s1" + s1.toString() + ";成绩：" + s1.average());
 }

}  

    父类和子类对象的转换

    类是java中的一种复合数据类型，与基本数据类型一样，java语言允许父类和子类的对象之间进行类型转换
当父类对象转换为子类对象时，必须要强制类型转换。格式如下
    (子类)父类对象
    //这个慢慢研究