一、继承
子类可以继承包内父类除private权限的成员；但是子类和父类不在同一个包中，子类就不能继承父类的private权限和默认权限的成员
//父类Person
package cn.edu.jxau.ruanjianxy;
public class Person {
public long stuID;
private int age;
boolean sex;
}
//包内子类Student
package cn.edu.jxau.ruanjianxy;
public class Student extends Person {
public boolean getSex(){
return sex;
}
}
//不同包内的子类Manager
import cn.edu.jxau.ruanjianxy.Person;
public class Manager extends Person {
public long getStuID(){
return stuID;
}
//错误，不同包内的子类不能继承父类默认权限的成员。
// public boolean getSex(){
// return sex;
// }
}
二、protected权限
protected又称为继承权限。在包外可以继承到父类的public和protected权限的成员。
package cn.edu.jxau.ruanjianxy;
public class Person {
public long stuID;
private int age;
protected String name;
boolean sex;
}
import cn.edu.jxau.ruanjianxy.Person;
public class Manager extends Person {
public long getStuID(){
return stuID;
}
public String getName(){
return name;//protected权限成员在包外也能继承
}
}
在包外，只能访问到包内类中public权限的成员。在包内，除了private权限的成员，其它权限成员都可以进行访问。
//测试类
import cn.edu.jxau.ruanjianxy.Person;
public class Test {
public static void main(String[] args) {
// TODO Auto-generated method stub
Person p = new Person();
// p.age = 5;//包外不能访问私有的成员
// p.sex = true;//包外不能访问默认权限的成员
// p.name = "dh";//包外不能访问到protected权限的成员
p.stuID = 20135689;
}
}
三、public、protected、默认、private
范围：public > protected > 默认 > private
1、public:在包内、包外都可以被子类继承，也可以被包内、包外其他的类访问到。
2、protected：在包内、包外都可以被子类继承，可以被包内其他类访问，但是包外的类不能访问到。
3、默认：只能被包内的子类继承，包外子类不能继承。可以被包内其他类访问，但是包外的类不能访问到。
4、private:包内、包久都不可以被子类继承，也不能被包内、包外其他的类访问。只能被其本身的方法访问。
四、成员变量的隐藏
当子类定义了和父类相同的成员变量名，在子类访问的是子类定义的成员变量，所以称为将父类的成员变量隐藏了。
//父类
package cn.edu.jxau.ruanjianxy;
public class Person {
public int age = 5;
}
//子类
package cn.edu.jxau.ruanjianxy;
public class Student extends Person {
public int age = 1;
public void show(){
System.out.println("age = " + age);
}
}
//测试类
package cn.edu.jxau.ruanjianxy;
public class Test1 {
public static void main(String[] args) {
Student s = new Student();
s.show();
}
}
如果想在子类中访问到父类继承过来的变量，怎么办？
可以使用关键字super进行访问
语法： super.变量；
//父类
package cn.edu.jxau.ruanjianxy;
public class Person {
public int age = 5;
}
//子类
package cn.edu.jxau.ruanjianxy;
public class Student extends Person {
public int age = 1;
public void show(){
System.out.println("age = " + super.age);
}
}
//测试类
package cn.edu.jxau.ruanjianxy;
public class Test1 {
public static void main(String[] args) {
Student s = new Student();
s.show();
}
}
例子：
//父类
package cn.edu.jxau.ruanjianxy;
public class Person {
public int age = 5;
}
//子类
package cn.edu.jxau.ruanjianxy;
public class Student extends Person {
public int age = 1;
public void show(){
System.out.println("age = " + super.age);
}
}
//测试类
package cn.edu.jxau.ruanjianxy;
public class Test1 {
public static void main(String[] args) {
Person p = new Person();
p.age = 6;
Student s = new Student();
s.age = 10;
s.show();//结果为5
}
}
五、成员方法的覆盖
当子类定义了和父类相同的成员方法时，在子类访问的是子类定义的成员方法，所以称为将父类的成员方法覆盖了。
package cn.edu.jxau.ruanjianxy;
public class Person {
public long stuID;
public int age = 5;
protected String name;
boolean sex;
public void show(){
System.out.println("person.age = " + age);
}
}
package cn.edu.jxau.ruanjianxy;
public class Student extends Person {
public int age = 1;
public void show(){
System.out.println("student.age = " + age);
}
public void execute(){
show();
}
}
package cn.edu.jxau.ruanjianxy;
public class Test1 {
public static void main(String[] args) {
Person p = new Person();
p.age = 6;
Student s = new Student();
s.age = 10;
s.execute();//子类的show()方法。
}
}
如需调用父类继承过来的方法，可使用关键字super。
语法： super.成员方法（）；
六、多态
一种表示，多种形态。
多态分两种：一种编译时多态，是通过重载完成。另一种是运行时多态，通过继承完成。
1、编译时多态。
编译时多态通过重载来完成。重载的意思是在同一个类中，允许方法名同时。通过参数的个数、类型和顺序来区分。
public class Car {
public void drive(){
System.out.println("开汽车");
}
public void drive(int minute){
System.out.println("开汽车需要" + minute + "分钟");
}
public void drive(String name){
System.out.println("开" + name + "汽车");
}
public void drive(String name, int minute){
System.out.println("开" + name + "汽车需要" + minute + "分钟");
}
public void drive(int minute,String name){
System.out.println("开" + name + "汽车需要" + minute + "分钟");
}
}
public class Test {
public static void main(String[] args) {
Car c = new Car();
c.drive();
c.drive("红旗");
c.drive("红旗", 10);
}
}
2、运行时多态
1）向上转型和向下转型
向上转型就是将子类对象转换成父类对象。
语法：
父类 父类对象 = new 子类的构造方法。
示例见工程bb.
向上转型后，子类特有方法将暂时丢失。
向下转型：本质上是还原，就是将原来向上转型后的对象还原到本身。
语法：
子类 子类对象 = （子类）已向上转型的父类对象。
