1、关键词:extends
2、格式:class 子类名 extends 父类名{
......
}
3、每个类(除Object类)有且只有一个父类,一个类可以有多个或零个子类。
4、子类和父类在同一个包中时,子类继承父类除private的成员变量和方法,子类和父类不在同一个包中,子类只会继承父类中protected和public的成员变量和方法。
public class People {
int age,leg=2,hand=2;
void getInformation(){
System.out.printf("%d岁,%d个腿,%d个手\t",age,leg,hand);
}
}
public class Student extends People{
int number;
void getNumber(){
System.out.printf("学号:%d\t",number);
}
int add(int a,int b){
return a+b;
}
}
public class UniverStudent extends Student{
int multi(int a,int b){
return a*b;
}
}
public class Example {
public static void main(String[] args) {
UniverStudent zhang=new UniverStudent();
zhang.number=123;
zhang.age=12;
zhang.hand=2;
zhang.leg=2;
zhang.getInformation();
zhang.getNumber();
System.out.print("会做加法");
int a=10,b=20;
int result=zhang.add(a, b);
System.out.printf("%d+%d=%d\n",a,b,result);
System.out.print("会做乘法");
result=zhang.multi(a, b);
System.out.printf("%d*%d=%d\n",a,b,result);
}
}
5、instanceof运算符(双目运算符)
左面操作元是对象,右面操作元是类,当左面的操作元是右面的类或子类创建的对象时,instanceof运算的结果是true,否则为false。
6、成员变量的隐藏
子类所声明的成员变量和从父类继承来的成员变量的名字相同时,子类就会隐藏从父类继承的成员变量,但子类仍然可以调用父类的继承方法来操纵被隐藏的成员变量。
7、用super操作被隐藏的成员变量和方法
如 super.x、super.f()
public class A {
int n;
float f(){
float sum=0;
for(int i=1;i<=n;i++){
sum=sum+i;
}
return sum;
}
}
public class B extends A {
int n;
float f(){
super.n=n;
float sum=super.f();
return sum/n;
}
float g(){
float c=super.f();
return c/2;
}
}
public class example {
public static void main(String[] args) {
B b=new B();
b.n=100;
float result1=b.f();
float result2=b.g();
System.out.println(result1);
System.out.println(result2);
}
}
8、super调用父类的构造方法
由于子类不继承父类的构造方法,因此,子类在其构造方法中需使用super来调用父类的构造方法。,而且super必须是子类构造方法的头一条语句,如果在子类的构造方法中没有明显地写出super关键字来调用父类的某个构造方法,那么默认有super();
public class Student {
int number;
String name;
Student(){
}
Student(int number,String name){
this.number=number;
this.name=name;
System.out.println("名字:"+name+"学号:"+number);
}
}
public class UniverStudent extends Student{
boolean 婚否;
UniverStudent(int number,String name,boolean b){
super(number,name);
婚否=b;
System.out.println("婚否:"+b);
}
}
public class example8 {
public static void main(String[] args) {
UniverStudent student=new UniverStudent(101,"李雷",true);
}
}
名字:李雷学号:101
婚否:true
9、重写
子类所重写的方法的方法名、参数个数、参数类型和父类的方法完全相同。
注意:重写父类的方法时,不允许降低方法的访问权限。访问权限从高到低的排列为public、protected、友好的、private.
10、final 关键字
final修饰类,则该类不能被继承,即不能有子类。
final修饰方法,该方法不允许子类重写。
final修饰成员变量或局部变量,该常量在运行期间不允许再发生变化,在声明变量时也必须指定该常量的值。
public class A {
final double PI=Math.PI;
public double getArea(final double r){
//r=r+1; 非法,不允许对final变量进行更新操作
return PI*r*r;
}
public final void speak(){
System.out.println("你好");
}
}
public class example {
public static void main(String[] args) {
A a=new A();
System.out.println("面积为:"+ a.getArea(11));
a.speak();
}
}
面积为:380.1327110843649
你好
11、对象的上转型对象
Animal a;
Tiger b=new Tiger();
a=b;
a 是b的上转型对象(老虎是动物)
上转型对象不能操纵子类新增的成员变量和子类新增的方法;
上转型对象可以访问子类继承或隐藏的成员变量,也可以调用子类继承或重写的实例方法。当实例方法被重写,上转型对象调用实例方法时调用的是子类重写的实例方法,不能调用子类重写的静态方法。
12、abstract关键字
abstract修饰类,1)不允许使用final和abstract同时修饰类;2)abstract类中可以有abstract类也可以有非abstract类;3)abstract类不能用new运算符创建对象;4)如果一个非abstract类是abstract的子类,那么该子类必须重写父类的abstract类,如果一个abstract类是abstract类的子类,它可以重写或继承父类的abstract类;5)abstract类的对象可以作上转型对象,该对象可以调用子类重写的方法。
abstract修饰方法,1)不允许使用final或static修饰abstract方法;2)abstract方法只允许声明,不允许实现(没有方法体);3)abstract方法只能出现在abstract类中。
abstract class girlFriend{
abstract void speak();
abstract void cook();
}
class chineseGirlFriend extends girlFriend{
void speak(){
System.out.println("你好");
}
void cook(){
System.out.println("会煮酸菜鱼");
}
}
class americanGirlFriend extends girlFriend{
void speak(){
System.out.println("hello");
}
void cook(){
System.out.println("roast beef");
}
}
class Boy{
girlFriend friend;
void setGirlFriend(girlFriend f){
friend=f;
}
void showGirlFriend(){
friend.speak();
friend.cook();
}
}
public class example {
public static void main(String args[]){
Boy boy=new Boy();
girlFriend girl=new chineseGirlFriend();//girl 是上转型对象
boy.setGirlFriend(girl);
boy.showGirlFriend();
girl=new americanGirlFriend();
boy.setGirlFriend(girl);
boy.showGirlFriend();
}
}