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);
}
}