JavaBean规范类
主要是以后做实体类使用(与数据库中的表一一对应的类)
package com.myc.day03;
public class Student {
// JavaBean 规范类
// 要求
// 类必须是具体的公有的
// 具有无参构造方法
// 提供用来操作成员变量的set 和 get方法
// 成员变量
private String name;
private int age;
// 构造方法
// 无参构造方法(必须)
public Student() {
}
// 有参构造方法(建议)
public Student(String name, int age) {
this.name = name;
this.age = age;
}
// 成员方法
public void study(){
System.out.println("学习中...........");
}
// get 和 set 方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
继承
子类(基类): 父类的儿子或者后代都可以叫子类
父类(超类): 被继承的类
继承: 就是子类继承父类的属性和行为, 使得子类对象具有与父类相同的属性和行为. 子类可以直接访问父类中非私有的属性和行为.
好处:1. 提高代码的复用性 2. 类与类之间产生了关系, 是多态的前提
格式
class 父类 {
}
class 子类 extends 父类{
}
举例
package com.myc.day03;
// 父类
public class Employee {
String name;
public void work(){
System.out.println("努力的工作中....");
}
}
子类
package com.myc.day03;
/**
* 定义讲师类 继承员工类Employee
*/
public class Teacher extends Employee{
public void printName(){
System.out.println("name" + name);
}
}
测试类
package com.myc.day03;
public class TestExtends {
public static void main(String[] args) {
Teacher teacher1 = new Teacher();
teacher1.name = "小明";
// 这是子类的方法
teacher1.printName();
// 调用父类的方法
teacher1.work();
}
}
继承后的特点
成员变量
- 成员变量不重名
如果子类父类中出现不重名的成员变量, 这时访问是没有影响的
package com.myc.day03;
public class Fu {
int num = 5;
}
package com.myc.day03;
public class Zi extends Fu {
int num2 = 6;
public void show(){
// 访问父类中的num
System.out.println("Fu num = " + num); // 继承而来
// 访问子类中的num2
System.out.println("Zi num2 = " + num2);
}
}
package com.myc.day03;
public class TestExtends2 {
public static void main(String[] args) {
Zi zi = new Zi();
zi.show();
}
}
- 成员变量重名
如果子类父类中出现重名的成员变量, 这时访问是有影响的(就近生效)
package com.myc.day03;
public class Fu {
int num = 5;
}
package com.myc.day03;
public class Zi extends Fu {
int num = 10;
public void show(){
// 访问父类中的num
System.out.println("Fu num = " + num);
// 访问子类中的num2
System.out.println("Zi num = " + num);
}
}
package com.myc.day03;
public class TestExtends2 {
public static void main(String[] args) {
Zi zi = new Zi();
zi.show();
}
}
子类和父类出现同名的成员变量, 子类需要访问父类中非私有属性时, 要使用
super关键字, 类似于之前学习的this修改代码
package com.myc.day03;
public class Zi extends Fu {
int num = 10;
public void show(){
// 访问父类中的num
System.out.println("Fu num = " + super.num);
// 访问子类中的num2
System.out.println("Zi num = " + this.num);
}
}
小贴士: 父类中的成员变量时非私有的, 子类可以直接访问, 若父类中的成员变量时私有了, 子类是不能直接访问的, 通常编码时候, 我们遵循的是封装原则, 使用的是private修饰成员变量, 如何访问父类中私有成员呢? 在父类中提供公有get xx set xx方法
继承后的方法
- 成员方法不重名
如果子类父类中出现不重名的成员方法, 这时访问是没有影响的
package com.myc.day03;
public class Fu {
int num = 5;
public void show(){
System.out.println("父类中 show方法被执行");
}
}
public class Zi extends Fu {
int num = 10;
public void show2(){
System.out.println("子类中 show2方法被执行");
}
}
public class TestExtends2 {
public static void main(String[] args) {
Zi zi = new Zi();
zi.show();
zi.show2();
}
}
- 成员方重名 -- 重写(Override)
子类可以根据需要, 定义特定于自己的行为, 既延续了父类功能的名称, 又根据子类的需要重新实现了父类的方法, 从而进行了扩展增强.
大白话: 子类代替了父类相同名字的方法(声明不变, 重新实现)
public class Fu {
int num = 5;
public void show(){
System.out.println("父类中 show方法被执行");
}
}
package com.myc.day03;
public class Zi extends Fu {
int num = 10;
public void show2(){
System.out.println("子类中 show2方法被执行");
}
@Override
public void show(){
// // 访问父类中的num
// System.out.println("Fu num = " + super.num);
// // 访问子类中的num2
// System.out.println("Zi num = " + this.num);
System.out.println("子类中show被执行...");
}
}
package com.myc.day03;
public class TestExtends2 {
public static void main(String[] args) {
Zi zi = new Zi();
zi.show();
// zi.show2();
}
}
重写的应用
public class Phone {
public void call(){
System.out.println("打电话");
}
public void showNum(){
System.out.println("显示来电号码");
}
}
package com.myc.day03;
public class MIPhone extends Phone {
// 重写父类的showNum方法
//增加自己的显示姓名和图片功能
@Override
public void showNum() {
// 有了这句父类中的实现仍然保留
// super.showNum();
//增加自己的显示姓名和图片功能
System.out.println("显示来电姓名");
System.out.println("显示头像");
}
}
public class TestExtends3 {
public static void main(String[] args) {
MIPhone miPhone = new MIPhone();
miPhone.call();
miPhone.showNum();
}
}
注意事项:
子类方法重写父类方法, 必须保证权限大于等于父类权限
子类方法重写父类方法, 返回值类型,函数名和参数列表都要一模一样
继承后的构造方法
子类是无法继承父类的构造方法的
package com.myc.day03;
public class Fu2 {
private int n;
Fu2(){
System.out.println("Fu2构造方法被调用");
}
}
package com.myc.day03;
public class Zi2 extends Fu2{
Zi2(){
// 调用父类的构造方法
// 这里是显示调用父类构造方法
// 不写 super()也会调用
super();
System.out.println("Zi2构造方法被调用");
}
}
package com.myc.day03;
public class TestExtends4 {
public static void main(String[] args) {
new Zi2();
}
}
案例
package com.myc.day03;
public class Animal {
public void eat(){
System.out.println("animal: eat");
}
Animal(){
}
}
package com.myc.day03;
public class Animal {
public void eat(){
System.out.println("animal: eat");
}
Animal(){
super();
show();
}
public void show(){
System.out.println("初始化");
}
public static void main(String[] args) {
new Animal();
}
}
public class TestExtends5 {
public static void main(String[] args) {
Cat cat = new Cat();
// cat.eat();
// cat.eatTest();
// Cat c2 = new Cat("haha", 90);
// Cat c3 = new Cat(12);
}
}
网友评论