继承
继承是什么？
继承:继承是面向对象程序设计不可缺少的设计思想,是实现代码可重用的根基，是提高代码可扩展性的主要途径。
继承是从已有的类中派生出新的类，新的类能吸收已有类的属性和行为，并能扩展新的能力。
1.在Java中使用extends关键字来表示继承关系。
2.Java不支持多继承，单继承使JAVA的继承关系很简单，一个类只能有一个直接父类。
3.继承之后子类可以调用父类的所有非私有属性和非私有方法
何时使用继承？
继承与真实世界类似
只要说“猫是动物”
狗也是动物
继承是代码重用的一种方式
继承的传递性
C类从B类继承,B类又从A类继承
那么C类就具有B类和A类的所有非私有属性和非私有方法
当一个没有继承任何一个类时,jvm会默认让类继承Object类
Object是 java为所有类提供的基类
//父类
public class ExtendsFather {
/*
父类/基类
在已有类的基础上,派生出新的子类,新类可以有父类的方法
提高可重用性和可扩展性
is-a关系 xxx是xxx 猫是动物,狗是动物
*/
private String name;
private int age;
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
public void birth(){
System.out.println("这是父类,派生出子类");
}
}
//子类
public class ExtendsSon extends ExtendsFather{
/*
在ExtendsFather 派生出 ExtendsSon
Java中,一个类只能直接继承一个父类
*/
public void call(){
System.out.println("叫霸霸");
}
public static void main(String[] args) {
//父类方法
ExtendsSon extendsSon = new ExtendsSon();
extendsSon.setName("父类");
System.out.println(extendsSon.getName());
extendsSon.setAge(10);
System.out.println(extendsSon.getAge());
extendsSon.birth();
//自己特有的方法
extendsSon.call();
}
}
//父类
//10
//这是父类,派生出子类
//叫霸霸
继承中的构造方法
子类构造方法总是先调用父类构造方法,默认情况下，调用父类无参构造方法
可以在子类构造方法的第一行，使用super关键字调用父类任意一个构造方法
如果用super,必须写在构造方法的第一句
如果子类的构造方法中没有显式地调用基类构造方法，则系统默认调用基类无参数的构造方法。
原因:子类创建后需要调用父类的方法,所以在创建子类对象时父类也需要同时被创建.
super关键字用途
super关键字代表父类的引用，在程序中主要的用途
在子类构造方法中要调用父类的构造方法，需要注意：super语句只能出现在子类构造方法体的第一行。
用“super.成员变量名”来引用父类成员变量
用“super.方法名（参数列表）”的方式访问父类的方法。
与this的区别，this通常指代当前对象，super通常指代父类
//父类
public class ReExtendsFather {
private String name;
private int age;
char sex;
//无参
public ReExtendsFather(){
super();
System.out.println("无参父类构造方法");
}
//有参
public ReExtendsFather(String name){
super();
System.out.println("有参父类构造方法");
}
public void eat(){
System.out.println("吃饭");
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge(){
return age;
}
}
//子类
public class ReExtendsSon extends ReExtendsFather{
private String type;
public ReExtendsSon(){
//可以写,也可以不写,不写默认调用无参的构造方法 要写必须写在第一行
super();
System.out.println("子类");
}
public void setType(String type) {
this.type = type;
}
public String getType(){
return type;
}
public void kind(){
//super还可以调用方法 super.方法
super.eat();
//super还以调用成员变量
super.sex = '男';
System.out.println(super.sex);
System.out.println("中华田园犬");
}
public static void main(String[] args) {
ReExtendsSon reExtendsSon = new ReExtendsSon();
reExtendsSon.kind();
reExtendsSon.setName("多多");
System.out.println(reExtendsSon.getName());
reExtendsSon.setAge(2);
System.out.println(reExtendsSon.getAge());
reExtendsSon.setType("麻花呀");
System.out.println(reExtendsSon.getType());
}
}
/*
无参父类构造方法
子类
吃饭
男
中华田园犬
多多
2
麻花呀
*/
重载
在子类中可以根据需要对从基类中继承来的方法进行重写。
方法重载规则:
方法名相同、参数列表相同；
返回值类型相同；
访问权限相同
即与父类方法结构完全相同
注意：构造方法不能重写
应用场景:
当父类的方法实现不能满足子类需求时,可以对方法进行重写( override)
当前案例对eat方法重写
//父类
public class ReExtendsFather {
private String name;
private int age;
char sex;
//无参
public ReExtendsFather(){
super();
System.out.println("无参父类构造方法");
}
//有参
public ReExtendsFather(String name){
super();
System.out.println("有参父类构造方法");
}
public void eat(){
System.out.println("吃饭");
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge(){
return age;
}
}
//子类
public class OverRide extends ReExtendsFather{
private int chance;
public void setChance(int chance) {
this.chance = chance;
}
public int getChance() {
return chance;
}
/*
方法重写
父类的功能不满足子类的功能,将父亲的方法拿过来重写
重写方法与父类方法一摸一摸,完全相同
构造方法不能重写
@Override Java注解 Java中事先定义好的一些注解标签 作用于类,属性,方法 编译时/运行时进行解析检测
@Override表示此方法从父类重写而来
*/
//此处重写父类的eat方法
@Override
public void eat() {
//有用保留 不用删除
super.eat(); //重用父类的功能
//子类自己重写的功能,对外表示都是eat方法
System.out.println("吃骨头");
}
public void fly(){
System.out.println("我会飞");
}
public static void main(String[] args) {
OverRide overRide = new OverRide();
//调用自己重写的eat方法
overRide.eat();
overRide.fly();
overRide.setName("小旋风");
System.out.println(overRide.getName());
}
}
关联
关联关系
对象和对象之间的连接。在Java中，关联关系的代码表现形式为一个类做为另一个类的属性类型存在。
即“有”的关系：”has-a”
单向关联
单向关联： A类关联B类。
public class HasPhone {
private HasPerson hasPerson;
}
双向关联
双向关联：A类关联B类,B类关联A类;
public class HasPerson {
private HasPhone hasPhone;
}
public class HasPerson {
public HasPhone getHasPhone() {
return hasPhone;
}
public void setHasPhone(HasPhone hasPhone) {
this.hasPhone = hasPhone;
}
}
public class HasPhone {
public HasPerson getHasPerson() {
return hasPerson;
}
public void setHasPerson(HasPerson hasPerson) {
this.hasPerson = hasPerson;
}
public static void main(String[] args) {
HasPhone hasPhone = new HasPhone();
HasPerson hasPerson = new HasPerson();
//人类关联手机类
hasPerson.setHasPhone(hasPhone);
System.out.println(hasPerson.getHasPhone());
//手机类关联人类
hasPhone.setHasPerson(hasPerson);
System.out.println(hasPhone.getHasPerson());
}
}
一对多关联
集合
public class Classes{
}
public class Student{
private List Classess；
}
数组
public class Classes{
}
public class Student{
private Classes[] Classess；
}
依赖
依赖关系(use-a)
指一个类A使用到了另一个类B
依赖关系的特性
这种关系是具有偶然性的、临时性的、非常弱的，但是类B的变化会影响到类A。
依赖具体表现
在代码层面，依赖关系表现为类B作为参数被类A在某个method
方法中使用
//人类
public class UsePerson {
private String name;
private int age;
//手机类作为人类的参数 用于人类的call方法中
public void call(UsePhone usePhone){
System.out.println("人类对手机的依赖");
}
}
//手机类
public class UsePhone {
private String name;
private int sort;
public static void main(String[] args) {
UsePerson usePerson = new UsePerson();
UsePhone usePhone = new UsePhone();
usePerson.call(usePhone);
}
}
关联与依赖
关联是“HAS”关系，依赖是“USE”关系
A类关联B类，指的是B类对象作为A类的属性存在，称为“has”关系。
A类依赖B类，指的是B的对象作为A类的方法参数存在，称为“use”关系
89
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
