package com.zhiyou100.day09;
public class Demo01 {
public static void main(String[] args) {
Student student=new Student(11,"张一",18);
Teacher teacher=new Teacher(31, "张二", 10000);
Worker worker=new Worker(43, "张三", "律师");
System.out.println(student.toString());
System.out.println(teacher.toString());
System.out.println(worker.toString());
}
}
class Student{
int age;
String name;
double score;
public String toString() {
return age + ", " + name + ", s" + score;
}
void show() {}
void add() {}
public Student(int age, String name, double score) {
super();
this.age = age;
this.name = name;
this.score = score;
}
}
class Teacher{
int age;
String name;
double salary;
public String toString() {
return age + ", " + name + ", " + salary;
}
void show() {}
void teach() {}
public Teacher(int age, String name, double salary) {
super();
this.age = age;
this.name = name;
this.salary = salary;
}
}
class Worker{
int age;
String name;
String job;
@Override
public String toString() {
return age + ", " + name + ", " + job ;
}
void show() {}
void work() {}
public Worker(int age, String name, String job) {
super();
this.age = age;
this.name = name;
this.job = job;
}
}
//总结：这三个类：相同内容很多 复用性比较差
改进:可以定义一个类Person：具有这三个类的共同的成员 然后让Person类被这三个类使用(继承)
此时这三个类就不需要再定义Person类中定义的所有内容了 此时就提高了类的复用性
继承：在类与类之间创建关联关系
1.2 概念
当一个新类拥有一个现有的类的所有成员时 此时可以让此新类从现有的类 派生、衍生
新类：子类
现有的类：父类、根类、超类
继承关键字：extends
继承格式：class 子类 extends 父类{
子类成员
}
特点：
1 子类继承父类 父类没有任何影响
2 子类中拥有父类中定义的所有成员
3 子类不能继承父类的构造方法
4 子类可以拥有一些父类没有的成员–子类特有成员
5 子类继承了父类的私有成员 但不能直接使用 只能通过父类的方法间接来使用
6 子类可以根据需求 重新定义父类的已有成员
子类重新定义父类的成员变量 要求：变量名相同即可
子类重新定义父类的成员方法 要求：返回值类型相同 方法名相同 参数列表相同(方法声明完全相同) 重写override
类似于：：进化
7 一类如果没有继承其他类 默认继承Object类 ：Object类–上帝类
8 java只支持类与类之间的单继承：一个类只能有一个直接父类 但可以有多个间接父类
继承：类与类之间创建关联关系 实现类的复用
public class Demo02Extends {
public static void main(String[] args) {
Fu02 f1=new Fu02(); //父类对象
Zi02 z1=new Zi02(); //子类对象
System.out.println(z1.a+":"+z1.b+":"+z1.c);
z1.show();
System.out.println(z1.a);
z1.smoke();
}
}
class Fu02 extends Object{//一类如果没有继承其他类 默认继承Object类
int a=11;
int b=13;
void show() {
System.out.println(this.k);
}
void hai() {}
public Fu02() {
super();
}
public Fu02(int a, int b) {
super();
this.a = a;
this.b = b;
}
private int k=1;//私有成员：只能在本类中访问
String enjoy="打牌";//此属性要被子类重新定义
void smoke() {//此方法要被子类重新定义--重写
System.out.println("水烟袋！");
}
}
class Zi02 extends Fu02{
//int a=-1;//子类重新定义
String a="aaaa";
int c=14;//子类特有
void hehe() {}
void show() {//子类重新定义
System.out.println(a+":"+b+":"+c);
}
String enjoy="打游戏";//子类重新定义：属性名相同即可
//父类的方法 无法满足子类的需求 子类对父类的方法进行改进--修改方法体
void smoke() {//从新定义父类的方法（不能满足子类需求）---重写--方法声明相同
System.out.println("过滤嘴！");
}
}
1.3 继承练习1
父类的创建：抽取所有子类的共同成员 形成父类父类存在的意义：为所有的子类定义规范
//刚学习继承：先写子类 再写父类 让子类继承父类
// 父类：把子类的共同成员提取出来 形成父类
// 一定使用eclipse:
//*创建三个类
//*正方形 square
//*长方形 rect
//*圆形 circle
//*必须属性：三个方法：show +qiuZC+qiuMJ 提供一些必须的构造方法
//1 定义子类
//3 让所有的子类继承父类
class Square extends Shape{
//1.1 创建 变量 描述数据
double bianChang;
String type="正方形";
//1.2 创建 方法 描述功能
void show() {
System.out.println(type+":bianChang="+bianChang);
}
double qiuZC() {
return 4*bianChang;
}
double qiuMJ() {
return bianChang*bianChang;
}
//构造方法重载：满足不同对象的需求：
Square(){}
Square(double bianChang){
this.bianChang=bianChang;
}
}
class Rect extends Shape{
double chang;
double kuang;
String type="长方形";//重新定义父类的成员变量
void show() {//子类重写
System.out.println(type+"：chang="+chang+",kuang="+kuang);
}
double qiuZC() {//子类重写
return 2*(chang+kuang);
}
double qiuMJ() {//子类重写
return chang*kuang;
}
//alt+shift+s
Rect(double chang, double kuang) {
this.chang = chang;
this.kuang = kuang;
}
Rect() {}
}
class Circle extends Shape{
double r; //子类特有
double pi=3.1415926;//子类特有
String type="圆形";//重新定义父类的成员变量
void show() { //子类重写
System.out.println(type+":r="+r);
}
double qiuZC() { //子类重写
return 2*pi*r;
}
double qiuMJ() { //子类重写
return pi*r*r;
}
public Circle(double r) {
this.r = r;
}
public Circle() {}
public void hehe() {}//子类特有
}
//父类的作用：为子类定义规范：如果是Shape类的子类：必须有type属性和qiuZC、qiuMJ、show方法
//2 定义父类
class Shape{
String type="形状";
void show() {
System.out.println(type);
}
double qiuZC() {//信息不完整：无法求周长
return 0;
}
double qiuMJ() {//信息不完整：无法求面积
return 0;
}
}
1.4 继承练习2
定义子类时：分清此成员是子类特有 还是 子类重新定义子类对象调用成员时：分清是子类特有、子类重新定义、父类继承
package com.zhiyou100.day09;
public class Demo04 {
public static void main(String[] args) {
Demo04Zi zi=new Demo04Zi();
System.out.println(zi.a);//子类重写定义的a：：：从父类继承的a被隐藏
System.out.println(zi.b);//子类从父类继承的b
System.out.println(zi.c);//子类特有的 c
zi.show();//子类重写后的show：：：从父类继承的show被隐藏
zi.hai();//子类从父类继承的hai
zi.hehe();//子类特有
}
}
//创建父类：提取子类的共同成员 形成父类
class Demo04Fu{
int a=1;
int b=2;
void show() {
System.out.println("父类：：：show");
}
void hai() {
System.out.println("父类：：：hai");
}
Demo04Fu(int a){}
}
class Demo04Zi extends Demo04Fu{
int a=11;//子类重新定义
int c=12;//子类特有
void show() {//重写
System.out.println("子类：：：show");
}
void hehe() {//子类特有
System.out.println("子类：：：hehe");
}
Demo04Zi(int a){
super(a);//调用父类的构造方法
}//Implicit super constructor Demo04Fu() is undefined. Must explicitly invoke another constructor
Demo04Zi(){
super(1);//所有的子类构造方法第一个语句必须是super(参数列表) 来调用父类的构造方法
}
}
2 super
this: 当前对象
使用场景1：方法中当成员变量与局部变量重名时 变量名默认指向局部变量
通过this.变量名来指向成员变量
注意：方法中成员前面默认有this.
使用场景2： 构造方法之间的相互调用 通过this(参数列表)；
// this(参数列表)必须是当前方法的第一个语句
super: 父类的; 超级的
使用场景1：当子类重新定义父类成员时 从父类继承的成员会被隐藏 （子类方法中调用这些成员时 默认指的是重新定义后的）
通过super.成员来调用父类被隐藏的成员
子类方法中调用父类成员：前面默认有super.
使用场景2： 所有的子类构造方法的默认通过super()调用父类无参数的构造方法
如果父类没有无参数的构造方法 需要显式通过super(参数列表)来调用父类有参数的构造方法
// 注意：super(参数列表)必须是第一个语句
package com.zhiyou100.day09;
public class Demo05Super {
public static void main(String[] args) {
//Demo05Zi zi=new Demo05Zi();
//zi.hehe();
Demo05Zi zi=new Demo05Zi(1.1);
}
}
class Demo05Fu{
int a=1;
int b=2;
void show() {
System.out.println("父类：：：show");
}
void hai() {
System.out.println("父类：：：hai");
}
//-----------构造方法
Demo05Fu(int a){}
Demo05Fu(){
System.out.println("Demo05Fu()");
}
}
class Demo05Zi extends Demo05Fu{
int a=11;//子类重新定义
int c=12;//子类特有
void show() {//重写
System.out.println("子类：：：show");
}
void hehe() {//子类特有
//System.out.println("子类：：：hehe");
System.out.println("a="+a);
System.out.println("super.a="+super.a);//调用父类的a
show();//调用的子类
//重写后的show
super.show();//调用父类的show
System.out.println(b+":"+super.b);
super.hai();
}
//------------构造方法
Demo05Zi(int a){
super(a);//调用父类的构造方法
}//Implicit super constructor Demo04Fu() is undefined. Must explicitly invoke another constructor
Demo05Zi(){
super(1);//所有的子类构造方法第一个语句必须是super(参数列表) 来调用父类的构造方法
}
Demo05Zi(double d){
//默认super()调用父类无参数的构造方法
System.out.println("Demo05Zi(double d)");
}
}
