(面相对象) 继承

最新推荐文章于 2020-06-01 22:43:33 发布
最新推荐文章于 2020-06-01 22:43:33 发布
阅读量154 收藏
点赞数 1
分类专栏： Java 文章标签： 面向对象
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36326116/article/details/89321106
版权

目录

 

继承概述：

好处：

弊端：

Java中继承的特点：

继承的注意事项：

继承中成员变量的关系:

this和super的区别：

继承中构造方法的关系：

如果父类没有无参构造方法，那么子类的构造方法会出现什么现象呢?

继承中成员方法的关系:

重写override和重载overload：

方法重写的注意事项：

Test1:

Test2:

Test3:

面试题：

final关键字：

面试题：final修饰局部变量的问题：

final修饰变量的初始化时机：

继承概述：

把多个类中相同的内容给提取出来定义到一个类中。

好处：

        A:提高了代码的复用性
        B:提高了代码的维护性
        C:让类与类之间产生了关系，是多态的前提

弊端：

类与类产生了关系，其实也是继承的一个弊端

        类的耦合性增强了。
        
        开发的原则：低耦合，高内聚。
        耦合：类与类的关系
        内聚：就是自己完成某件事情的能力

Java中继承的特点：

        A:Java只支持单继承，不支持多继承。
            有些语言是支持多继承，格式：extends 类1,类2,...
        B:Java支持多层继承(继承体系)

继承的注意事项：

    继承的注意事项：
        A:子类只能继承父类所有非私有的成员(成员方法和成员变量)
        B:子类不能继承父类的构造方法，但是可以通过super(马上讲)关键字去访问父类构造方法。
        C:不要为了部分功能而去继承
            class A {
                public void show1(){}
                public void show2(){}
            }
            
            class B {
                public void show2(){}
                public void show3(){}
            }
            
            //我们发现B类中出现了和A类一样的show2()方法，所以，我们就用继承来体现
            class B extends A {
                public void show3(){}
            }
            这样其实不好，因为这样你不但有了show2(),还多了show1()。
            有可能show1()不是你想要的。
            
    那么，我们什么时候考虑使用继承呢?
        继承其实体现的是一种关系："is a"。
            Person
                Student
                Teacher
            水果
                苹果
                香蕉
                橘子
                
        采用假设法。
            如果有两个类A,B。只有他们符合A是B的一种，或者B是A的一种，就可以考虑使用继承。

继承中成员变量的关系:

    类的组成：
        成员变量：
        构造方法：
        成员方法：
    而现在我们又讲解了继承，所以，我们就应该来考虑一下，类的组成部分的各自关系。
    
    继承中成员变量的关系:
        A:子类中的成员变量和父类中的成员变量名称不一样，这个太简单。
        B:子类中的成员变量和父类中的成员变量名称一样，这个怎么玩呢?
            在子类方法中访问一个变量的查找顺序：
                a:在子类方法的局部范围找，有就使用
                b:在子类的成员范围找，有就使用
                c:在父类的成员范围找，有就使用
                d:如果还找不到，就报错。

this和super的区别：

            this代表本类对应的引用。
            super代表父类存储空间的标识(可以理解为父类引用,可以操作父类的成员)

            怎么用呢?
            A:调用成员变量
                this.成员变量 调用本类的成员变量
                super.成员变量 调用父类的成员变量
            B:调用构造方法
                this(...)    调用本类的构造方法
                super(...)    调用父类的构造方法
            C:调用成员方法
                this.成员方法 调用本类的成员方法
                super.成员方法 调用父类的成员方法

class Father {
	public int num = 10;
}

class Son extends Father {
	public int num = 20;
	
	public void show() {
		int num = 30;
		System.out.println(num);
		System.out.println(this.num);
		System.out.println(super.num);
	}
}

class ExtendsDemo5 {
	public static void main(String[] args) {
		Son s = new Son();
		s.show();
	}
}

继承中构造方法的关系：

        A:子类中所有的构造方法默认都会访问父类中空参数的构造方法
        B:为什么呢?
            因为子类会继承父类中的数据，可能还会使用父类的数据。
            所以，子类初始化之前，一定要先完成父类数据的初始化。
            
            注意：子类每一个构造方法的第一条语句默认都是：super();

class Father {
    int age;


    public Father() {
        System.out.println("Father的无参构造方法");
    }
    
    public Father(String name) {
        System.out.println("Father的带参构造方法");
    }
}


class Son extends Father {
    public Son() {
        //super();
        System.out.println("Son的无参构造方法");
    }
    
    public Son(String name) {
        //super();
        System.out.println("Son的带参构造方法");
    }
}    


class ExtendsDemo6 {
    public static void main(String[] args) {
        //创建对象
        Son s = new Son();
        System.out.println("------------");
        Son s2 = new Son("林青霞");//会再次调用父类的无参构造方法
    }
}

如果父类没有无参构造方法，那么子类的构造方法会出现什么现象呢?

:报错。    

如何解决呢?    
        A:在父类中加一个无参构造方法
        B:通过使用super关键字去显示的调用父类的带参构造方法
        C:子类通过this去调用本类的其他构造方法
            子类中一定要有一个去访问了父类的构造方法，否则父类数据就没有初始化。
            
    注意事项：
        this(...)或者super(...)必须出现在第一条语句上。
        如果不是放在第一条语句上，就可能对父类的数据进行了多次初始化，所以必须放在第一条语句上。否则，就会有父类数据的多次初始化

class Father {
	/*
	public Father() {
		System.out.println("Father的无参构造方法");
	}
	*/
	
	public Father(String name) {
		System.out.println("Father的带参构造方法");
	}
}

class Son extends Father {
	public Son() {
		super("随便给");
		System.out.println("Son的无参构造方法");
		//super("随便给");
	}
	
	public Son(String name) {
		//super("随便给");
		this();
		System.out.println("Son的带参构造方法");
	}
}

class ExtendsDemo7 {
	public static void main(String[] args) {
		Son s = new Son();
		System.out.println("----------------");
		Son ss = new Son("林青霞");
	}
}

继承中成员方法的关系:

A:子类中的方法和父类中的方法声明不一样，这个太简单。
B:子类中的方法和父类中的方法声明一样，这个该怎么玩呢?
       通过子类对象调用方法：
                a:先找子类中，看有没有这个方法，有就使用
                b:再看父类中，有没有这个方法，有就使用
                c:如果没有就报错。

重写override和重载overload：

    方法重写：子类中出现了和父类中方法声明一模一样的方法。
    
    方法重载：
        本类中出现的方法名一样，参数列表不同的方法。与返回值无关。

    子类对象调用方法的时候：
        先找子类本身，再找父类。
        
    方法重写的应用：
        当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。
        这样，即沿袭了父类的功能，又定义了子类特有的内容。

class Phone {
	public void call(String name) {
		System.out.println("给"+name+"打电话");
	}
}

class NewPhone extends Phone {
	public void call(String name) {
		//System.out.println("给"+name+"打电话");
		super.call(name);
		System.out.println("可以听天气预报了");
	}
}

class ExtendsDemo9 {
	public static void main(String[] args) {
		NewPhone np = new NewPhone();
		np.call("林青霞");
	}
}

方法重写的注意事项：

        A:父类中私有方法不能被重写
            因为父类私有方法子类根本就无法继承
        B:子类重写父类方法时，访问权限不能更低
            最好就一致
        C:父类静态方法，子类也必须通过静态方法进行重写
            其实这个算不上方法重写，但是现象确实如此，至于为什么算不上方法重写，多态中我会讲解
            
        子类重写父类方法的时候，最好声明一模一样。

class Father {
	//private void show() {}
	
	/*
	public void show() {
		System.out.println("show Father");
	}
	*/
	
	void show() {
		System.out.println("show Father");
	}
	/*
	public static void method() {
		
	}
	*/
	
	public void method() {
		
	}
}

class Son extends Father {
	//private void show() {}

	/*
	public void show() {
		System.out.println("show Son");
	}
	*/
	
	public void show() {
		System.out.println("show Son");
	}
	
	
	public static void method() {
	
	}
	
	/*
	public void method() {
	
	}
	*/
}

class ExtendsDemo10 {
	public static void main(String[] args) {
		Son s = new Son();
		s.show();
	}
}

Test1:

/*
	看程序写结果：
		A:成员变量	就近原则
		B:this和super的问题
			this访问本类的成员
			super访问父类的成员
		C:子类构造方法执行前默认先执行父类的无参构造方法
		D:一个类的初始化过程
			成员变量进行初始化
				默认初始化
				显示初始化
				构造方法初始化
				
	结果：
		fu
		zi
		30
		20
		10
*/
class Fu{
	public int num = 10;
	public Fu(){
		System.out.println("fu");
	}
}
class Zi extends Fu{
	public int num = 20;
	public Zi(){
		System.out.println("zi");
	}
	public void show(){
		int num = 30;
		System.out.println(num); //30
		System.out.println(this.num); //20
		System.out.println(super.num); //10
	}
}
class ExtendsTest {
	public static void main(String[] args) {
		Zi z = new Zi();
		z.show();
	}
}

Test2:

/*
	看程序写结果：
		A:一个类的静态代码块,构造代码块,构造方法的执行流程
			静态代码块 > 构造代码块 > 构造方法
		B:静态的内容是随着类的加载而加载
			静态代码块的内容会优先执行
		C:子类初始化之前先会进行父类的初始化
		
	结果是：
		静态代码块Fu
		静态代码块Zi
		构造代码块Fu
		构造方法Fu
		构造代码块Zi
		构造方法Zi
*/
class Fu {
	static {
		System.out.println("静态代码块Fu");
	}

	{
		System.out.println("构造代码块Fu");
	}

	public Fu() {
		System.out.println("构造方法Fu");
	}
}

class Zi extends Fu {
	static {
		System.out.println("静态代码块Zi");
	}

	{
		System.out.println("构造代码块Zi");
	}

	public Zi() {
		System.out.println("构造方法Zi");
	}
}

class ExtendsTest2 {
	public static void main(String[] args) {
		Zi z = new Zi();
	}
}

Test3:

/*
	看程序写结果：
		A:成员变量的问题
			int x = 10; //成员变量是基本类型
			Student s = new Student(); //成员变量是引用类型
		B:一个类的初始化过程
			成员变量的初始化
				默认初始化
				显示初始化
				构造方法初始化
		C:子父类的初始化(分层初始化)
			先进行父类初始化，然后进行子类初始化。
			
	结果：
		YXYZ
		
	问题：
		虽然子类中构造方法默认有一个super()
		初始化的时候，不是按照那个顺序进行的。
		而是按照分层初始化进行的。
		它仅仅表示要先初始化父类数据，再初始化子类数据。
*/
class X {
	Y b = new Y();
	X() {
		System.out.print("X");
	}
}

class Y {
	Y() {
		System.out.print("Y");
	}
}

public class Z extends X {
	Y y = new Y();
	Z() {
		//super
		System.out.print("Z");
	}
	public static void main(String[] args) {
		new Z(); 
	}
}

面试题：

1：方法重写和方法重载的区别?方法重载能改变返回值类型吗?

方法重写：
    在子类中，出现和父类中一模一样的方法声明的现象。
    
方法重载：
    同一个类中，出现的方法名相同，参数列表不同的现象。


方法重载能改变返回值类型，因为它和返回值类型无关。


Override：方法重写
Overload：方法重载

2：this关键字和super关键字分别代表什么?以及他们各自的使用场景和作用。

this:代表当前类的对象引用
super:代表父类存储空间的标识。(可以理解为父类的引用，通过这个东西可以访问父类的成员)

场景：
    成员变量：
        this.成员变量
        super.成员变量
    构造方法：
        this(...)
        super(...)
    成员方法：
        this.成员方法
        super.成员方法

final关键字：

    由于继承中方法有一个现象：方法重写。
    所以，父类的功能，就会被子类给覆盖调。
    有些时候，我们不想让子类去覆盖掉父类的功能，只能让他使用。
    这个时候，针对这种情况，Java就提供了一个关键字：final
    
    final:最终的意思。常见的是它可以修饰类，方法，变量。

    final可以修饰类，方法，变量
    
    特点：
        final可以修饰类，该类不能被继承。
        final可以修饰方法，该方法不能被重写。(覆盖，复写)
        final可以修饰变量，该变量不能被重新赋值。因为这个变量其实常量。
        
    常量：
        A:字面值常量
            "hello",10,true
        B:自定义常量
            final int x = 10;

class Fu {
	public int num = 10;
	public final int num2 = 20;

	/*
	public final void show() {
	
	}
	*/
}

class Zi extends Fu {
	// Zi中的show()无法覆盖Fu中的show()
	public void show() {
		num = 100;
		System.out.println(num);
		
		//无法为最终变量num2分配值
		//num2 = 200;
		System.out.println(num2);
	}
}

class FinalDemo {
	public static void main(String[] args) {
		Zi z = new Zi();
		z.show();
	}
}

面试题：final修饰局部变量的问题：

        基本类型：基本类型的值不能发生改变。
        引用类型：引用类型的地址值不能发生改变，但是，该对象的堆内存的值是可以改变的。

class Student {
	int age = 10;
}

class FinalTest {
	public static void main(String[] args) {
		//局部变量是基本数据类型
		int x = 10;
		x = 100;
		System.out.println(x);
		final int y = 10;
		//无法为最终变量y分配值
		//y = 100;
		System.out.println(y);
		System.out.println("--------------");
		
		//局部变量是引用数据类型
		Student s = new Student();
		System.out.println(s.age);
		s.age = 100;
		System.out.println(s.age);
		System.out.println("--------------");
		
		final Student ss = new Student();
		System.out.println(ss.age);
		ss.age = 100;
		System.out.println(ss.age);
		
		//重新分配内存空间
		//无法为最终变量ss分配值
		ss = new Student();
	}
}

final修饰变量的初始化时机：

        A:被final修饰的变量只能赋值一次。
        B:在构造方法完毕前。(非静态的常量)

class Demo {
	//int num = 10;
	//final int num2 = 20;
	
	int num;
	final int num2;
	
	{
		//num2 = 10;
	}
	
	public Demo() {
		num = 100;
		//无法为最终变量num2分配值
		num2 = 200;
	}
}

class FinalTest2 {
	public static void main(String[] args) {
		Demo d = new Demo();
		System.out.println(d.num);
		System.out.println(d.num2);
	}
}

 

 

 

 

道山_靓仔
关注
专栏目录
面向对象--继承
简之恨寒的博客
08-08 2492
继承是面向对象最显著的一个特性。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。继承是类与类之间的关系，是一个很简单很直观的概念，与现实世界中的继承（例如儿子继承父亲财产）类似。继承可以理解为一个类从另一个类获取方法和属性的过程。如果类B继承于类A，那么B就拥有A的方法和属性。...
继承（一）
gafeng123456的博客
02-03 297
多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可 通过extends关键字可以实现类与类的继承class 子类名 extends 父类名 {} 单独的这个类称为父类，基类或者超类；这多个类可以称为子类或者派生类。 有了继承以后，我们定义一个类的时候，可以在一个已经存在的类的基础上，还可以定义自己的新成员 继承的好处 提高了代码的复用
面相对象之继承
weixin_30323961的博客
07-25 83
继承 什么是继承? 　继承是一种关系,描述两个对象之间是什么关系,程序中继承描述的是类和类之间的关系 例如: a继承了b ,那么a就可以使用b已经存在的方法和属性 　　　　a称之为子类 ; b称之为父类,也称之为基类 为什么要使用继承 继承的一方可以直接使用被继承的一方已经有东西 , 其目的是为了重用已经有过的代码,提高代码的重用行 如何使用继承: 首先语法: c...
javascript面相对象编程，封装与继承
weixin_30827565的博客
01-10 89
一、封装 　　var line = '<div>----------------------------------------------</div>';//1.对象的原始模式 　　var obj = {name : '', color : ''}生成两个实例对象 　　var hengda = {}; // 创建一个空对象 　　hengda.n...
第三次学JAVA再学不好就吃翔(part34)--多态的成员访问
小山羊的学习日志
06-01 245
学习笔记，仅供参考 文章目录面向对象多态多态概述多态的成员访问成员变量成员方法静态成员方法 面向对象 多态 多态概述 多态的概述 事物存在的多种形态 多态实现的前提 要有继承关系 要有方法重写 要有父类引用指向子类对象 举个例子 class PolymorphicTest1 { public static void main(String[] args) { Animal a = new Bunny(); //父类引用指向子类对象 a.eat(); } }
JavaSE学习笔记（七）—— 继承&final关键字
VNOpU2015的专栏
05-07 162
一、继承 1.1 引入 　　首先我来写两个代码： class Student { String name; int age; public Student(){} //getXxx()/setXxx() public void eat() { System.out.println("...
详解C#面相对象编程中的继承特性
12-31
继承（加上封装和多态性）是面向对象的编程的三个主要特性（也称为“支柱”）之一。 继承用于创建可重用、扩展和修改在其他类中定义的行为的新类。其成员被继承的类称为“基类”，继承这些成员的类称为“派生类”。...
理解Objective-C的变量以及面相对象的继承特性
01-05
OC点语法和变量作用域 一、点语法 （一）认识点语法 声明一个Person类: 代码如下: #import @interface Person : NSObject {  int _age;//默认为@protected ...– (void)setAge:(int)age;...// 不能写成self.a
详解JavaScript基于面向对象之继承
11-23
一、面向对象继承机制 在面向对象编程中，继承是一种设计模式，它允许子类继承父类的特征和行为。在这个几何形状的例子中，形状是所有类的基类，包括椭圆形和多边形。椭圆形有焦点数量的属性，而圆形作为椭圆形的...
java 代码块，继承，final
bobo的博客
01-20 132
###07.01_面向对象(代码块的概述和分类)(了解)(面试的时候会问,开发不用或者很少用) * A:代码块概述       * 在Java中，使用{}括起来的代码被称为代码块。 * B:代码块分类       * 根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块(多线程讲解)。         局部代码块：只要是和局部有关系的，都是和方法有关系的   ...
(10)Java学习笔记——面向对象04——继承
xiexiecm的博客
01-16 376
继承 继承的好处： 1/提高了代码的复用性 2/让类与类之间产生了联系，给第三个特征多态提供了前提。 class ExtendsDemo { public static void main(String[] args) { Student s = new Student(); s.name="zhangsan"; s.age=20; s.study();
java第四次作业
weixin_34074740的博客
04-18 164
JAVA第四次作业 1.学习使用思维导图对Java面向对象编程的知识点（封装、继承和多态）进行总结。 http://images2015.cnblogs.com/blog/1079821/201704/1079821-20170416175810790-345604021.png 2.阅读下面程序，分析是否能编译通过？如果不能，说明原因。应该如何修改？程序的运行结果是什么？为什么子类的构造方法在运...
继承跟类别的区别
weixin_34240520的博客
12-02 167
类别（category）和继承的区别？*类别：类别是对一个功能完备的类的一种补充，就像是一个东西的主要基本功能都完成了，可以用类别为这个类添加不同的组件，使得这个类能够适应不同情况的需求。比如animal这个类，具有eat和run等方法，想给这个类添加一个bark的方法，可以用类别。*继承：多个类具有相同的实例变量和方法时，考虑用继承。即子类可以继承父类的相同特性。如animal具有年龄和体重两...
JAVA语言基础-面向对象(继承）
weixin_33973609的博客
08-15 176
2019独角兽企业重金招聘Python工程师标准>>> ...
Java基础班第九天（上）多态
weixin_40079205的博客
10-06 237
三个内容 ：多态、抽象类、接口  第一节：讲解这个多态的概念 class Demo1_Poly { public static void main(String[] args) { Animal c; c = new Cat(); c.eat(); } /* A:多态的概述 事物存在的多种形式 B:多态的前提 1：要有继承关系 2：要有方法重写 3...
(Java常用类) Regex(正则表达)
Scoson
04-04 1985
目录 案例引入（校验qq号码）： 正则表达式：符合一定规则的字符串： 验证QQ登录改进版 判断功能 分割功能： 替换功能： 获取功能： 附：常用正则表达式 案例引入（校验qq号码）： /* * 校验qq号码. * 1:要求必须是5-15位数字 * 2:0不能开头 * * 分析： * A:键盘录入一个QQ号码 * B:写...
(Java常用类) StringBuffer:线程安全的可变字符串
Scoson
04-05 896
* 安全 -- 同步 -- 数据是安全的 * 不安全 -- 不同步 -- 效率高一些 目录 StringBuffer和String的区别? StringBuffer的构造方法： StringBuffer的方法： StringBuffer的添加功能： StringBuffer的删除功能: StringBuffer的替换功能： StringBuffer的反转功能： StringBu...
(集合) Collection接口
Scoson
04-11 552
目录 案例引入对象数组： 集合的由来： 数组和集合的区别? Collection的功能概述： 1：添加功能 2:删除功能 3:判断功能 4:获取功能 5:长度功能 6:交集功能 7：把集合转换为数组 // 测试不带All的方法 // 测试带All的方法 集合的遍历。其实就是依次获取集合中的每一个元素。 Object[] toArray():把集合转成数组，可以实...
(集合) 集合嵌套练习（存储并遍历）
Scoson
07-07 540
目录 目录 练习一：ArrayList<HashMap<String, String>> 练习二：HashMap<String, HashMap<String, Integer>>,> 练习三：HashMap<String, ArrayList<String>>,> 练习四：获取字符串中每一个字母出现的次...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值