6.2Java面对对象(下)

976-沈同学

发表文章数:64

热门标签

首页 » Java » 正文

面对对象(下)-1

继承

继承概述:

	1.多个类存在相同的属性和行为时,将这些内容抽取到单独一个类中,
	  那么多个类无需再定义这些属性和行为,只要继承那个类即可。
	  
	2.通过extends关键字可以实现类与类的继承;
		public class 子类名 extends 父类名 {}
		
	3.单独的这个类称为父类,这多个类称为子类。
	
	4.有了继承以后,我们定义一个类的时候,可以在一个已经有的类基础上,定义自己的新成员。

继承的好处与弊端:

继承的好处:
	1.提高了代码的复用性;
	2.提高了代码的维护性;
	3.让类与类之间产生关系;
继承的弊端:
	让类与类之间产生关系,也就让类的耦合性增强了
	开发原则:高内聚,低耦合;
		内聚:就是自己完成某件事的能力;
		耦合:类与类之间的关系;

Java继承中成员变量的特点:

	1.Java中类只支持单继承,不支持多继承;(son ->father or son->gradefather)
	2.Java中类支持多层继承;(son ->father;father ->gradefather)
	-->son可以使用gradefather的方法

	3.成员变量名称不一样,使用的时候很简单。
	4.成员变量一样的情况(就近原则)
		a:在方法的局部变量范围找,如果有就是用;
		b:在子类的成员变量范围找,如果有就是用;
		c:在父类的成员变量范围找,如果有就只用;
		d:如果找不到,就报错;

super关键字:

super和this的用发很像:
	this:代表本类对象的引用
	super:代表父类对象引用(代表父类的存储空间)
		用法:
		访问成员变量--->	this.成员变量
					  super.成员变量

		访问构造方法--->	this(...)
						super(...)
						
		访问成员方法--->	this.成员方法
						super.成员方法

Java继承中构造方法的特点:

Java继承中构造方法访问特点:
	1.子类构造方法执行前都会执行父类无参构造方法;
		原因:因为子类继承父类,会继承父类的非私有成员。
			 而子类在初始化的时候,可能会使用父类的数据,
			 如果父类数据没有先初始化,子类就不能使用这些数据,
			 所以在子类初始化之前,*(一定要先完成父类数据的初始化)(无参构造方法)
	注意:在子类的构造方法中,默认第一行有一条语句:super();

	假如父类中没有无参构造方法如何解决?
		a:添加一个无参构造方法(建议使用)
		b:可以通过super访问父类的带参构造方法(不建议使用)

Java继承中构造方法的特点:

Java继承中构造方法的访问特点:
	子类中方法和父类中方法不一样
	子类方法和父类的方法的声明一样,调用哪一个?
	
通过子类对象调用方法:
	a:在子类中找,有就是用
	b:在父类中找,有就是用
	c:如果没有就报错

Java继承中方法重写的概述和使用:

方法重写:子类中出现了和父类中一模一样的方法声明的情况。
方法重写的应用:当子类需要父类的功能,而功能主体子类又有自己特有内容的时候。

@Override 这是注解,用来标记一个方法,表明该方法时重写父类的方法;

方法重写的注意事项:
	a:父类的私有方法不能被重写;
	b:子类重写父类方法时,访问权限不能更低;(*建议与父类访问权限一致)
	
	
(private << 默认修饰符(什么都不带) << public)

继承的练习

学生与老师案例:
	学生类:
		成员变量:name,age
		构造方法:无参,带参
		成员方法:getXxx(),setXxx(),study()
		
	老师类:
		成员变量:name,age
		构造方法:无参,带参
		成员方法:getXxx(),setXxx(),teach()

这两个类中相同的代码比较多,所以提取一个父类。

	人类:
		 成员变量:name,age
		 构造方法:无参,带参
		 成员方法:getXxx(),setXxx(),teach()

	学生类:
		 继承人类
		 study()
	老师类:
		 继承人类
		 teach()

多态

多态:同一个对象,在不同时刻体现出来的不同状态
举例:
	猫是猫,猫也是动物
	水可以是液体,固体,气体
	
Java中多态的前提
	a:有继承关系
	b:有方法重写
	c:有父类引用指向子类对象
		Fu f = new Fu();
		Zi z = new Zi();
		Fu f = new Zi();

多态中成员访问特点:

成员变量:
	编译看左边,执行看左边;
成员方法:
	编译看左边,执行看右边;

编译与执行访问不一样的原因:

		因为成员放法有重写,而变量没有。
package com.scy;

public class Animal {
    public int age = 40;

    public void eat(){
        System.out.println("吃东西");
    }
}
package com.scy;

public class Cat extends Animal{
    public int age =30;
    public String name = "猫";

    @Override
    public void eat(){
        System.out.println("猫吃鱼");
    }

    public void playGame(){
        System.out.println("玩游戏");
    }
}
package com.scy;

public class MainApp {
    public static void main(String[] args) {
        Animal a = new Cat();
        System.out.println(a.age); --->40
//        System.out.println(a.name);  成员变量编译看左边,执行看左边
        a.eat();	--->“猫吃鱼”
//        a.playGame(); 成员方法,编译看左边,执行看右边
    }
}

多态的好处与弊端:

多态的好处:提供了程序的扩展性;
多态的弊端:不能使用子类的特有功能;
package com.scy;     # 父类

public class Animal {
    public int age = 40;

    public void eat(){
        System.out.println("吃东西");
    }
}
package com.scy;  # 子类

public class Cat extends Animal{

    @Override
    public void eat(){
        System.out.println("猫吃鱼");
    }
}
package com.scy;	#多态可扩展性的体现;

public class AnimalOperate {
//    public void useAnimal(Cat c){ 
// 						Cat c = new Cat();
//        c.eat();
//    }
//    public void useAnimal(Dog d){ 
// 						Dog d = new Dog();
//        d.eat();
//    }
    public void useAnimal(Animal a ){ 
    				//Animal a = new Cat();多态
        a.eat();
    }
}
package com.scy;	# 测试类

public class MainApp {
    public static void main(String[] args) {
      AnimalOperate ao = new AnimalOperate();
      Cat c = new Cat();
      ao.useAnimal(c);
      Dog d = new Dog();
      ao.useAnimal(d);
    }
}

多态中的转型问题:

向上转型:
	从子到父
	父类引用指向子类对象
向下转型:
	从父到子
	父类引用转为之类对象
public class MainApp {
    public static void main(String[] args) {
     //多态
        Animal a  = new Cat();  # 向上转型
        						# 父类引用指向子类对象
        a.eat();
        a.playGame();//无法访问子类特有方法
        // Cat c = new Cat();
         //这样虽然可以访问子类的特有方法,但是不合理,
         //内存中有两个猫对象;
        // 如何使用一个子类访问子类特有方法?
        // 就要使用多态中的转型了;
        # 父类引用转为之类对象
        Cat c = (Cat)a;
        c.eat();
        c.playGame()
    }
多态转型内存图解:
(ClassCastException)类型转换异常

6.2Java面对对象(下)

多态的练习:

package com.scy;

public class MainApp {
    public static void main(String[] args) {
        Animal a = new Cat();   //向上转型
        a.eat();
        Cat c = (Cat) a; //向下转型
        c.eat();
        c.play();
        a = new Dog(); //向上转型
        a.eat();
        Dog d = (Dog) a; //向下转型
        d.eat();
        d.lookDoor();
    }
}
标签:

拜师教育学员文章:作者:976-沈同学, 转载或复制请以 超链接形式 并注明出处 拜师资源博客
原文地址:《6.2Java面对对象(下)》 发布于2020-03-09

分享到:
赞(0) 打赏

评论 抢沙发

评论前必须登录!

  注册



长按图片转发给朋友

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏

Vieu3.3主题
专业打造轻量级个人企业风格博客主题!专注于前端开发,全站响应式布局自适应模板。

登录

忘记密码 ?

您也可以使用第三方帐号快捷登录

Q Q 登 录
微 博 登 录