文章目录
一、继承
在我们日常写代码时,不难发现在定义的类中常常会有很多重复变量,因此提出了继承的概念,专门用来进行共性抽取,实现代码复用。
继承的概念:
它允许程序员在保持原有类特性的基础上进行扩展,增加新功能,这样产生新的类,称派生类。
继承主要解决的问题是:共性的抽取,实现代码复用。
1.继承的语法
在Java中如果要表示类之间的继承关系,需要借助extends关键字,具体如下:
修饰符 class 子类 extends 父类{
//…
}
以猫,狗为例:
class Animal{
String name = "阿黄";
int age = 3;
public void eat(){
System.out.println(name+"正在吃饭");
}
public void sleep() {
System.out.println(name + "正在睡觉");
}
}
class Dog extends Animal {
void bark(){
System.out.println(name+",汪汪叫");
}
}
public class test{
public static void main(String[] args) {
Dog dog = new Dog();
System.out.println(dog.name);
System.out.println(dog.age);
dog.bark();
}
}
2.父类成员访问
(1)子类与父类不存在相同成员名
class DogFather{
String name = "大黄";
int age1 = 3;
}
class Dog extends DogFather {
int age2 ;
public void New(){
name = "小黄"; //访问从父类中继承下来的名字并更改
age2 = 1; //访问子类自己的年龄
System.out.println(name + "今年" + age2 + "岁");
}
void bark(){
System.out.println(name+",汪汪叫");
}
}
public class test{
public static void main(String[] args) {
Dog dog = new Dog();
dog.New();
dog.bark();
}
}
2.子类与父类有相同成员名
class DogFather{
String name = "大黄";
int age = 3;
int heavy = 60;
}
class Dog extends DogFather {
int age ; //与父类名称相同类型相同
String name;
double heavy = 30.0; //名称相同但类型不同
public void New(){
age = 1;
name = "小黄";
System.out.println(name + "今年" + age + "岁" + heavy + "kg");
}
void bark(){
System.out.println(name+",汪汪叫");
}
}
public class test{
public static void main(String[] args) {
Dog dog = new Dog();
dog.New();
dog.bark();
}
}
注:
如果访问的成员变量子类中有,优先访问自己的成员变量。
如果访问的成员变量子类中无,则访问父类继承下来的,如果父类也没有定义,则编译报错。
如果访问的成员变量与父类中成员变量同名,则优先访问自己的。
成员变量访问遵循就近原则,自己有优先自己的,如果没有则向父类中找。
3.子类访问父类成员方法
1.成员方法名称不同
class First{
public void A(){
System.out.println("方法A");
}
}
class Second extends First{
public void B(){
System.out.println("方法B");
}
public void print(){
A(); //访问父类A
B(); //访问子类B
}
}
public class test{
public static void main(String[] args) {
Second second = new Second();
second.print();
}
}
2.成员方法名称相同
class First{
public void A(){
System.out.println("父类:方法A");
}
public void B(){
System.out.println("父类:方法B");
}
}
class Second extends First{
public void B(){
System.out.println("子类:方法B");
}
public void A(int a){
System.out.println("带int参数的方法A");
}
public void print(){
A(); //访问父类A
A(2); //访问子类中带有int参数的方法
B(); //优先访问子类B,最基类的无法访问
}
}
public class test{
public static void main(String[] args) {
Second second = new Second();
second.print();
}
}
注:
通过子类对象访问父类与子类中不同名方法时,优先在子类中找,找到则访问,否则在父类中找,找到则访问,否则编译报错。
通过派生类对象访问父类与子类同名方法时,如果父类和子类同名方法的参数列表不同(重载),根据调用方法适传递的参数选择合适的方法访问,如果没有则报错;
4.super关键字
在设计程序时我们常常会遇到父类和子类有相同成员名的情况,因此,我们需要一种方法来在子类中修改父类成员变量。
在Java中提供了super关键字,主要方法:在子类方法中访问父类成员。
代码如下:
class Father{
int a;
int b;
public void A(){
System.out.println("父类中的方法A");
}
}
class Son extends Father{
int a;
int b;
public void A(){
System.out.println("子类中的方法A");
}
public void print(){
a = 100;
b = 101;
System.out.println("子类的 a:"+a+" 子类的 b:"+b);
//子类中变量a,b。
super.a = 200;
super.b = 201;
System.out.println("父类的 a:"+super.a+" 父类 b:"+super.b);
//父类中的变量a,b
A();
super.A();
}
}
public class test{
public static void main(String[] args) {
Son son = new Son();
son.print();
}
}
注:
- 只能在非静态方法中使用
- 在子类方法中,访问父类的成员变量和方法。
super和this的区别
相同点:
- 都是Java中的关键字
- 只能在类的非静态方法中使用,用来访问非静态成员方法和字段
- 在构造方法中调用时,必须是构造方法中的第一条语句,并且不能同时存在。
不同点:
- this是当前对象的引用,当前对象即调用实例方法的对象,super相当于是子类对象中从父类继承下来部分成员的引用。
- 在非静态成员方法中,this用来访问本类的方法和属性,super用来访问父类继承下来的方法和属性
- 在构造方法中:this(…)用于调用本类构造方法,super(…)用于调用父类构造方法,两种调用不能同时在构造方法中出现
- 构造方法中一定会存在super(…)的调用,用户没有写编译器也会增加,但是this(…)用户不写则没有。
5.对静态,实例,构造方法代码块的执行顺序探究
1.无继承关系的顺序
代码如下:
class Find{
int a;
public void A(int a){
this.a = a;
System.out.println("构造方法");
}
{
System.out.println("实例代码");
}
static{
System.out.println("静态代码");
}
}
public class test {
public static void main(String[] args) {
Find find1 = new Find();
find1.A(10);
System.out.println("__________________");
Find find2 = new Find();
find2.A(20);
}
}
总结:
- 静态代码块先执行,并且只执行一次,在类加载阶段执行
- 当有对象创建时,才会执行实例代码块,实例代码块执行完成后,造方法执行
2.在继承关系上的顺序
代码如下:
class Father {
int a;
public Father(int a) {
this.a = a;
System.out.println("构造方法");
}
{
System.out.println("实例代码");
}
static {
System.out.println("静态代码");
}
}
class Son extends Father {
public int b;
public Son(int b) {
super(b);
System.out.println("构造代码");
}
{
System.out.println("实例代码");
}
static {
System.out.println("静态代码");
}
}
public class test {
public static void main(String[] args) {
Son son = new Son(10);
System.out.println("_____________");
Son son1 = new Son(20);
}
}
总结:
1、父类静态代码块优先于子类静态代码块执行,且是最早执行
2、父类实例代码块和父类构造方法紧接着执行
3、子类的实例代码块和子类构造方法紧接着再执行
4、第二次实例化子类对象时,父类和子类的静态代码块都将不会再执行
二、多态
多态的概念:完成某个行为,当不同的对象去完成时会产生出不同 的状
态。
1.多态的实现条件
- 必须在继承体系下
- 子类必须要对父类中方法进行重写
- 通过父类的引用调用重写的方法
在代码运行时,当传递不同类对象时,会调用对应类中的方法。
class Animal{
String name;
int age;
public Animal(String name,int age){
this.name = name;
this.age = age;
}
public void eat(){
System.out.println(name+"正在吃饭");
}
}
class Cat extends Animal{
public Cat(String name,int age){
super(name,age);
}
public void eat(){
System.out.println(name+ "在吃鱼");
}
}
class Dog extends Animal{
public Dog(String name,int age){
super(name,age);
}
public void eat(){
System.out.println(name+"吃骨头");
}
}
public class test {
// 编译器在编译代码时,并不知道要调用Dog 还是 Cat 中eat的方法
// 等程序运行起来后,形参a引用的具体对象确定后,才知道调用那个方法
// 注意:此处的形参类型必须时父类类型才可以
public static void eat(Animal a){
a.eat();
}
public static void main(String[] args) {
Dog dog = new Dog("大黄",3);
Cat cat = new Cat("小咪",3);
eat(cat);
eat(dog);
}
}
2.重写
重写(override):也称为覆盖。重写是子类对父类非静态、非private修饰,非final修饰,非构造方法等的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变,核心重写!
重写的规则:
1.子类在重写父类的方法时,一般必须与父类方法原型一致: 返回值类型 方法名 (参数列表) 要完全一致。
2.访问权限不能比父类中被重写的方法的访问权限更低。
3.父类被static、private修饰的方法、构造方法都不能被重写。
重写的设计原则:
对于已经投入使用的类,尽量不要进行修改。最好的方式是:重新定义一个新的类,来重复利用其中共性的内容,并且添加或者改动新的内容。
3.向上转型
向上转型:实际就是创建一个子类对象,将其当成父类对象来使用。
语法格式:父类类型 对象名 = new 子类类型()
代码如下:
class Animal{
String name;
int age;
public Animal(String name,int age){
this.name = name;
this.age = age;
}
public void eat(){
System.out.println(name+"正在吃饭");
}
}
class Cat extends Animal{
public Cat(String name,int age){
super(name,age);
}
public void eat(){
System.out.println(name+ "在吃鱼");
}
}
class Dog extends Animal{
public Dog(String name,int age){
super(name,age);
}
public void eat(){
System.out.println(name+"吃骨头");
}
}
public class test {
// 2. 方法传参:形参为父类型引用,可以接收任意子类的对象
public static void eatFood(Animal a){
a.eat();
}// 3. 作返回值:返回任意子类对象
public static Animal buyAnimal(String var){
if("狗" == var){
return new Dog("狗狗",1);
}else if("猫" == var){
return new Cat("猫猫", 1);
}else{
return null;
}
}
public static void main(String[] args) {
Animal cat = new Cat("元宝",2); // 1. 直接赋值:子类对象赋值给父类对象
Dog dog = new Dog("小七", 1);
eatFood(cat);
eatFood(dog);
Animal animal = buyAnimal("狗");
animal.eat();
animal = buyAnimal("猫");
animal.eat();
}
}
如有不足,欢迎指正!