/*子父类中变量的特点*/
情况一：
class Fu
{
int num=3;
}
class Zi extends Fu
{
int num=5;
}
class Q1
{
public static void main(String[] args)
{
Zi z=new Zi();
System.out.println(z.num); //打印结果为5，表明当子父类出现同名变量时，优先打印子类变量
}
}
情况二：
class Fu
{
private int num3=4;
int num1=3;
}
class Zi extends Fu
{
int num2=5;
}
class Q1
{
public static void main(String[] args)
{
Zi z=new Zi();
System.out.println(z.num1+"......"+z.num2+"...."); //表明子类继承父类可以继承父类中未被私有的变量
}
}
情况三：
/*关键字：super*/
class Fu
{
int num=3;
}
class Zi extends Fu
{
int num=5;
public void show()
{
System.out.println(super.num+"....."+num); //当子父类出现同名变量时，super.表示父类对象
}
}
class Q1
{
public static void main(String[] args)
{
Zi z=new Zi();
z.show();
}
}
情况四：
class Fu
{
int num=3;
}
class Zi extends Fu
{
//int num=5;
public void show()
{
System.out.println(this.num); //打印结果为3，这可以看作子类继承父类，子类中含父类变量
}
}
class Q1
{
public static void main(String[] args)
{
Zi z=new Zi();
z.show();
}
}
/*子父类函数的特点*/
情况一：
class Fu
{
void show1()
{
System.out.println("Fu show");
}
}
class Zi extends Fu
{
void show2()
{
System.out.println("Zi show");
}
}
class Q1
{
public static void main(String[] args)
{
Zi z=new Zi();
z.show1();
z.show2(); //打印结果为：Fu show
} Zi show
} //表示子类继承父类会继承父类未私有的函数
情况二：
/*重写或覆盖*/
//当子类和父类有相同函数名，但内容不同时，子类会将父类该函数覆盖（重写）掉
class Fu
{
void show()
{
System.out.println("Fu show");
}
}
class Zi extends Fu
{
void show()
{
System.out.println("Zi show");
}
}
class Q1
{
public static void main(String[] args)
{
Zi z=new Zi();
z.show(); //打印结果为 Zi show
}
}
情况三：
/*子父类函数中super的利用*/
class Fu
{
void show()
{
System.out.println("Fu show");
}
}
class Zi extends Fu
{
void show()
{
//System.out.println("Fu show");
super.show(); //当子类需要用到父类功能中的内容时，利用super.可以简化代码
System.out.println("Zi show");
}
}
class Q1
{
public static void main(String[] args)
{
Zi z=new Zi();
z.show();
}
}
注意事项：1.对于覆盖来说，子类的权限必须大于或等于父类 权限大小比较： public > protected > private
2.静态只能覆盖静态。
/*重载和重写的区别*/
/*重载*/
同一个类下的同名函数，例如：
class Q1
{
public int tool(int a,int b)
{
//
}
public void tool(int a,int b,double c)
{
//
}
}
//overload重载只和参数列表有关系，参数个数，参数类型，参数顺序，与返回值类型无关。
/*重写*/
//在子父类中，同名定义(返回值类型相同)相同内容不同的函数，子类会覆盖父类，父类仍然存在，只是没用被调用
例二：//super()
class Fu
{
Fu()
{
System.out.println("阿秋");
}
}
class Zi extends Fu
{
Zi()
{
//super(); //注意，这是一个隐式的调用子类构造函数的代码
System.out.println("阿秋来了");
}
}
/*子父类super的其他作用*/
class Person
{
private String name;
Person(String name)
{
this.name=name;
}
void show()
{
System.out.println(name);
}
}
class Student extends Person
{
Student(String name) //父类已经定义了name的属性，子类省略
{
super(name); //super对于构造函数调用的格式
}
void method()
{
super.show(); //super对于一般函数调用的方式
}
}
class Q1
{
public static void main(String[] args)
{
Student ss=new Student("阿秋");
ss.method();
}
}
/*关键字final*/
特点：
1.final 可以修饰类，函数，变量;
2.被 final 修饰的类不能被继承，最终类(用处：为了避免子类继承父类将父类功能覆写);
3.被 final 修饰的方法不能被覆写;(会有一个类中有能被覆写的和不能被覆写的);
4.被 final 修饰的变量是一个常量，既可以是成员变量也可以是局部变量。
a.被修饰的变量确定永久是该值，无法更改;
b.final 修饰的常量名各个字母都大写，如果由多个单词组成，用_(下划线)隔开
public static final 全局常量