1 继承(二)
案例:Demo1
public class Demo1 { public static void main(String[] args) { Bmw bmw = new Bmw(); bmw.name = "宝马"; bmw.no = "555555"; bmw.type = "豪华版"; bmw.price = 200000.1; bmw.color = "白色"; bmw.show(); bmw.start(); bmw.run(); bmw.stop(); } } class Car{//父类 //属性 String name; String no; int speed = 0; String color; //方法 void start(){ speed = 100; System.out.println(name+"启动了"); } void run(){ System.out.println(name+"在行驶,当前"+ "的速度是"+speed); } void stop(){ speed = 0; System.out.println(name+"刹车了,当前"+ "的速度是"+speed); } } //编写一个Car类(父类) //属性:车名,车牌,速度(int speed=0),颜色 //方法:void start():启动,speed=100,输出启动了 //void run():行驶,输出车名以及当前的速度 //void stop():刹车,speed=0,输出车名以及当前速度 class Bmw extends Car{ //属性 double price; String type; //方法 void show(){ System.out.println(name+","+no+"," +speed+","+color+","+price +","+type); } }
2 变量的隐藏(属性的覆盖)
子类编写的属性的名字跟父类中继承过来的属性名一致,子类编写的属性会覆盖从父类中继承过来的属性。
案例:Demo2
public class Demo2 { public static void main(String[] args) { Foo2 foo = new Foo2(); System.out.println(foo.name); } } class Foo1{ String name = "卫青"; } class Foo2 extends Foo1{ String name = "霍去病"; } public class Demo3 { public static void main(String[] args) { Eoo2 eoo = new Eoo2(); System.out.println(eoo.num1);//true } } class Eoo1{ int num1 = 100; } class Eoo2 extends Eoo1{ boolean num1 = true; //变量的隐藏只看子类和父类中的属性的名字是否一致, //跟类型无关。 }
变量的隐藏跟属性的类型无关,只要子类编写的属性的名字跟父类中继承过来的属性名一致,就覆盖了。
3 方法重写(方法覆盖)
子类编写的方法覆盖了从父类中继承过来的方法。
1) 方法重写要求子类编写的方法的名字和参数,必须跟要覆盖父类中的方法的名字和参数一致。
2) 参数一致:参数的类型和个数一致,跟参数的名字无关。
案例:Demo4
public class Demo4 { public static void main(String[] args) { Koo2 koo = new Koo2(); koo.f1(); } } class Koo1{ void f1(){ System.out.println("今天天气很好"); System.out.println("父类Koo1中编写的方法"); } } class Koo2 extends Koo1{ void f1(){ System.out.println("子类Koo2中重写" + "父类Koo1中的方法f1()"); } } public class Demo5 { public static void main(String[] args) { User1 user = new User1(); user.name = "张三"; user.age = 26; user.job = "经理"; user.address = "北京"; user.email = "san@126.com"; user.salary = 30000.1; user.show(); } } class Person1{//父类 //属性 String name; int age; String job; double salary; //方法 void show(){ System.out.println(name+","+age+"," +job+","+salary); } } //设计一个Person1(父类) //属性:姓名,年龄,职位,工资 //方法:void show():输出每一个属性的值 class User1 extends Person1{ //属性 String address; String email; //方法 void show(){ System.out.println(name+","+age+"," +job+","+salary+","+address +","+email); } } public class Demo6 { public static void main(String[] args) { Zoo2 zoo = new Zoo2(); zoo.f1(100,200); } } class Zoo1{ void f1(int a,int b){ int sum = a + b; System.out.println("sum="+sum); System.out.println("父类Koo1中的方法" + "f1()"); } } class Zoo2 extends Zoo1{ void f1(int num1,int num2){ int result = num1 * num2; System.out.println("result="+result); System.out.println("子类Zoo2中的方法" + "f1()重写父类Zoo1中的方法f1()"); } }
3) 方法重写跟方法重载的区别?
a) 方法重写在子类和父类之间,子类编写的方法覆盖了从父类中继承过来的方法。方法重载在一个类的内部,方法名相同,参数不同的多个方法。
b) 方法重写要求子类和父类中要重写方法的名字和参数一致。参数一致,参数的类型和个数一致,跟参数的名字无关。方法重载中要求重载的多个方法的名字一致,参数要不同,参数不同,参数的类型或者个数不同,跟参数的名字无关。
c) 方法重写的目的,使用子类重新编写的方法来覆盖从父类中继承过来的方法。方法重载是把功能相似的方法起同一个名字,用户只需要记住一个名字,就可以调用多个方法,减少用户的记忆量,方便方法的使用。
4 继承中的构造方法
子类可以继承父类的属性和方法,但是不能继承父类中的构造方法,可以在子类的构造方法中,调用父类中的构造方法。
1)如果父类中没有空参(没有参数)构造方法,则子类必须在自己的构造方法的第1行,使用super(参数)来调用父类中的带参数的构造方法。
super(参数):在子类构造方法的第1行使用,调用父类中带参数的构造方法。
案例:Demo7
public class Demo7 { } class Noo1{ //属性 String name; int age; double salary; //构造方法 Noo1(String name,int age,double salary){ this.name = name; this.age = age; this.salary = salary; } } class Noo2 extends Noo1{ //属性 String address; String phone; //构造方法 Noo2(String name,int age,double salary, String address,String phone){ //super(参数):在子类构造方法第1行使用,调用父类 //中带参数的构造方法 super(name,age,salary); this.address = address; this.phone = phone; } } public class Demo8 { public static void main(String[] args) { User2 user = new User2("徐达",36,"将军", "漠北",2000000.1,"da@126.com"); user.showAll(); } } class Person2{ //属性 String name; int age; String job; String address; //构造方法 Person2(String name,int age,String job, String address){ this.name = name; this.age = age; this.job = job; this.address = address; } //方法 void show(){ System.out.println(name+","+age+"," +job+","+address); } } class User2 extends Person2{ //属性 double salary; String email; //构造方法 User2(String name,int age,String job, String address,double salary, String email){ super(name,age,job,address); this.salary = salary; this.email = email; } //方法 void showAll(){ this.show(); System.out.println("工资:"+salary); System.out.println("邮箱:"+email); } }
2)如果父类中含有空参的构造方法,则子类根据需要任何编写自己的构造方法,而不需要强制使用super(参数)来调用父类中的构造方法。
案例:Demo9
public class Demo9 { } class Moo1{ //属性 String name; int age; String job; String address; //构造方法 Moo1(String name,int age,String job, String address){ this.name = name; this.age = age; this.job = job; this.address = address; } Moo1(){ } } class Moo2 extends Moo1{ //属性 String phone; double comm; //构造方法 Moo2(String name,int age,String job, String address,String phone, double comm){ /* this.name = name; this.age = age; this.job = job; this.address = address; */ super(name,age,job,address); this.phone = phone; this.comm = comm; } } public class Demo10 { public static void main(String[] args) { Midea midea = new Midea("美的","壁挂式", 27,"黑色",5000.22); midea.show(); midea.hot(3); midea.cool(8); } } class Kongtiao{ //属性 String name; String type; int degree; String color; //构造方法 Kongtiao(String name,String type, int degree,String color){ this.name = name; this.type = type; this.degree = degree; this.color = color; } Kongtiao(){ } //方法 void show(){ System.out.println(name+","+type+"," +degree+","+color); } void hot(int degree){ this.degree = this.degree + degree; System.out.println(name+"升高了"+degree +"度以后,当前的温度是"+this.degree); } void cool(int degree){ this.degree = this.degree - degree; System.out.println(name+"降低了"+degree +"度以后,当前的温度是"+this.degree); } } //设计一个Kongtiao类(父类) //属性:名称,类型,温度(int degree),颜色 //构造方法:1)给每一个属性赋值 2)空参的构造方法 //方法:void show():输出名称,类型,温度,颜色 //void hot(int degree):升高degree度 //this.degree = this.degree+degree //void cool(int degree):降低degree度 class Midea extends Kongtiao{ //属性 double price; //构造方法 Midea(String name,String type, int degree,String color, double price){ super(name,type,degree,color); this.price = price; } //方法 void show(){ System.out.println(name+","+type+"," +degree+","+color+","+price); } }
3)在企业中,一般都建议在父类中编写一个空参的构造方法,方便子类构造方法的编写。
案例:Demo11
public class Demo11 { public static void main(String[] args) { Worker worker = new Worker("韦一笑",32,"侠客", 2000.1,"光明顶","xiao@126.com"); worker.show(); worker.showAll(); worker.showYearSal(); Manager manager = new Manager("任我行",45,"教主", 2001.1,10000000.1,"1333333333"); manager.show(); manager.showYearSal(); } } class Emp{ //属性:姓名,年龄,职位,工资 String name; int age; String job; double salary; //构造方法 Emp(String name,int age,String job, double salary){ this.name = name; this.age = age; this.job = job; this.salary = salary; } Emp(){ } //方法 void show(){ System.out.println(name+","+age+"," +job+","+salary); } void showYearSal(){ double result = salary * 12; System.out.println(name+"的年薪是"+ result); } } class Worker extends Emp{ //属性:姓名,年龄,职位,工资,地址,邮箱 String address; String email; //构造方法 Worker(String name,int age,String job, double salary,String address, String email){ super(name,age,job,salary); this.address = address; this.email = email; } //方法 void showAll(){ this.show(); System.out.println("地址:"+address); System.out.println("邮箱:"+email); } } class Manager extends Emp{ //属性:姓名,年龄,职位,工资,奖金,电话 double comm; String phone; //构造方法: Manager(String name,int age,String job, double salary,double comm, String phone){ super(name,age,job,salary); this.comm = comm; this.phone = phone; }//方法: void show(){ System.out.println(name+","+age+"," +job+","+salary+","+comm+ ","+phone); } void showYearSal(){ double result = salary*12+comm; System.out.println(name+"年薪是"+result); } }
综合案例:
设计一个Emp类(父类)
属性:姓名,年龄,职位,工资
构造方法:1)给每一个属性赋值 2)空参的构造方法
方法:void show():输出姓名,年龄,职位,工资
void showYearSal(): 输出姓名和年薪(工资*12)
编写一个Worker类(子类),继承Emp
属性:姓名,年龄,职位,工资,地址,邮箱
构造方法:给所有属性赋值
方法:void showAll():输出每一个属性值
void showYearSal():输出姓名和年薪(工资*12)
编写一个Manager类(子类),继承Emp
属性:姓名,年龄,职位,工资,奖金,电话
构造方法:给每一个属性赋值
方法:void show():输出每一个属性值
void showYearSal():输出姓名和年薪(工资*12+奖金)
在main中,分别创建Worker和Manager对象,调用其方法
5 访问控制修饰符(一)
1)public:公共的,可以用来修饰类,属性,构造方法,以及方法,被public修饰类,属性,构造方法以及方法,可以任意进行访问。
案例:Demo12
public class Demo12 { public static void main(String[] args) { Coo coo1 = new Coo(); System.out.println(coo1.name); } } class Coo{ public String name = "张辽"; }
2)private:私有,可以用来修饰属性,构造方法以及方法,被privae修饰属性,构造方法以及方法,只能在本类的内部访问,外界无法访问。
案例:Demo13
public class Demo13 { public static void main(String[] args) { Yoo yoo = new Yoo(); System.out.println(yoo.name); // System.out.println(yoo.age); //被private修饰的属性,只能在本类的内部访问,外界 //无法访问 yoo.showAge(); } } class Yoo{ public String name = "张三"; private int age = 21; public void showAge(){ System.out.println("age="+age); } }