精华内容
下载资源
问答
  • java继承与多态

    2018-06-01 10:55:10
    Java继承与多态专题讲解,详细生动,例子丰富,适合初学者
  • Java继承与多态

    2019-03-30 10:10:59
    Java继承与多态

    一、继承

    继承是由已有类创建新类的机制。子类继承了父类原有的属性与方法,也可以增加新得属性与方法,也可以重写父类中的某些方法。系统默认Object类为所有类的父类。

    • Java中类没有多继承,接口有多继承。

    • 子类继承父类,可以得到父类的全部属性和方法 (除了父类的构造方法),但不见得可以直接访问(比如,父类私有的属性和方法)。

    示例

    package able;
    
    public class Person {
    	String name;
    	double height,weight;
    	
    	public Person(String name, double height, double weight) {
    		super();
    		this.name = name;
    		this.height = height;
    		this.weight = weight;
    	}
    
    	void thing(){
    		System.out.println("工作...");
    	}
    	
    	public String toString() {
    		return "姓名:"+name+"身高:"+height+"体重:"+weight;
    	}
    	
    	public static void main(String[] args) {
    		Student a = new Student("xxx",0,0,"1000",1);
    		Student b = new Student("xxx",0,0,"1010",2);
    		System.out.println(a.equals(b));
    		new Student("xxx",0,0,"1000",1).thing();
    	}
    	
    }
    
    class Student extends Person{
    	
    	public Student(String name, double height, double weight,String id,int grade) {
    		super(name, height, weight);
    		this.id = id;
    		this.grade = grade;
    		// TODO Auto-generated constructor stub
    	}
    	
    	String id;
    	int grade;
    	
    	void thing() {
    		super.thing();
    		System.out.println("学习...");
    	}
    	
    	Person who() {
    		return new Person("null",175,60);
    	}
    	
    	@Override
    	public int hashCode() {
    		final int prime = 31;
    		int result = 1;
    		result = prime * result + ((id == null) ? 0 : id.hashCode());
    		return result;
    	}
    	@Override
    	public boolean equals(Object obj) {
    		if (this == obj)
    			return true;
    		if (obj == null)
    			return false;
    		if (getClass() != obj.getClass())
    			return false;
    		Student other = (Student) obj;
    		if (id == null) {
    			if (other.id != null)
    				return false;
    		} else if (!id.equals(other.id))
    			return false;
    		return true;
    	}
    }
    
    • student类中的super(name, height, weight);用于调动父类的构造方法
    • student类中的thing()方法里面的super.thing();用于调动父类的thing()方法

    二、方法重写

    方法重写满足以下规则

    1. “==”: 方法名、形参列表相同。

    2. “≤”:返回值类型和声明异常类型,子类小于等于父类。

    3. “≥”: 访问权限,子类大于等于父类。

    以上示例中出现了方法重写
    J2SE 5.0以上版本可修改重写方法的返回值类型(重写的返回值类型必须是父类中同意返回值类型的子类

    public class TestSubClass {
    	TestSubClass(){
    		System.out.println("父类构造方法被调用");
    	}
    	
    	TestSubClass test() {
    		int a = 1;
    		System.out.println("父类test()方法被调用");
    		return new TestSubClass();
    	}
    	
    	public static void main(String[] args) {
    		SubClass a = new SubClass();
    		a.test();
    	}
    	
    }
    class SubClass extends TestSubClass{
    	
    	SubClass(){
    		System.out.println("子类构造方法被调用");
    	}
    	
    	SubClass test() {
    		System.out.println("子类test()方法被调用");
    		return new SubClass();
    	}
    }
    

    测试结果为:

    父类构造方法被调用
    子类构造方法被调用
    子类test()方法被调用
    父类构造方法被调用
    子类构造方法被调用
    
    • 由此可知编译器在调动子类构造方法前先调用父类无参构造方法(有参构造方法需显式使用super调用

    三、Object类

    Object类主要方法:clone()、finalize()、equals()toString()。最常用的是后面2个。
    Object类中不能被重写的方法(被定义为final类型):getClass()、notify()、notifyAll()、wait()等

    public class TestObject {
    	public String toString() {
    		return "在"+getClass().getName()+"类中改写toString()方法";
    	}
    	public static void main(String[] args) {
    		TestObject test = new TestObject();
    		System.out.println(test);
    	}
    }
    //结果:在TestObject类中改写toString()方法
    

    四、封装

    封装是面向对象的三大特性(封装、继承、多态)之一,封装简单来讲就是将自己的数据隐藏起来。

    举个例子:别人向你借钱,传统的面向过程的做法是别人去你家拿,拿多少有时候你也不知道。面向对象的做法是别人向你发出请求:我要借多少钱,至于你借给他多少,如何借这些都是由你自己内部的机制自己完成。用户不需要知道你的内部结构(实现细节)是怎样的,他只需要拿到钱。

    五、多态

    public class TestPoly {
    
    	public static void animalCry(Animal a) {
    		a.shout();
    	}
    	
    	public static void main(String[] args) {
    		Animal a1 = new Dog();    //向上转型
    		animalCry(a1);
    		a1.shout();
    		//这句不能通过编译:a1.action();
    		
    		Animal a2 = new Cat();
    		animalCry(a2);
    		a2.shout();
    		
    		Dog d1 = (Dog) a1;    //向下转型,需强制类型转换
    		d1.action();
    	}
    }
    
    class Animal{
    	void shout() {
    		System.out.println("叫了一声");
    	}
    }
    class Dog extends Animal{
    
    	void shout() {
    		System.out.println("旺旺旺");
    	}
    	
    	void action() {
    		System.out.println("看门");
    	}
    }
    
    class Cat extends Animal{
    	void shout() {
    		System.out.println("喵喵喵");
    	}
    }
    
    • 3个条件:继承方法重写父类引用指向子类对象
    • 父类的引用对象无法调用子类特有的方法 (除非向下转型)
    • 向上转型:从具体的类(子类)到抽象的类(父类),安全。
    • 向下转型:与向上转型相反,需要显式说明才能转换。
    • instanceof可以用于判断某个类是否是一个类的子类
    展开全文
  • Java继承与多态实验报告西 安 邮 电 大 学(计算机学院)课内实验报告实验名称: 继承与多态专业名称: 计算机科学与技术班 级: 计科1405班学生姓名: 高宏伟学 号: 指导教师: 刘霞林实验日期: 2016.10.13一、实验...

    Java继承与多态实验报告

    西 安 邮 电 大 学

    (计算机学院)

    课内实验报告

    实验名称: 继承与多态

    专业名称: 计算机科学与技术

    班 级: 计科1405班

    学生姓名: 高宏伟

    学 号: 指导教师: 刘霞林

    实验日期: 2016.10.13

    一、实验目的

    通过编程和上机实验理解 Java 语言的继承和多态特性,掌握变量的隐藏、方法的覆盖、重载,掌握抽象类和接口的使用。

    二、实验要求

    1.编写体现类的继承性(成员变量、成员方法、成员变量隐藏)的程序。

    2.编写体现类的多态性(成员方法重载)的程序。

    3.编写体现类的多态性(构造方法重载)的程序。

    4.编写使用接口的程序。

    三、实验内容

    (一)类的继承

    1.创建公共类Student.

    (1)编写程序文件 Student.java,源代码如下:

    public class Student

    {

    protectedString name; //具有保护修饰符的成员变量

    protected int number;

    void setData(String m,int h) //设置数据的方法

    {

    name =m;

    number= h;

    }

    public void print() //输出数据的方法

    {

    System.out.println(name+", "+number);

    }

    }

    (2)编译 Student.java,产生类文件Student.class。

    2.创建继承的类Undergraduate

    (1)程序功能:通过 Student 类产生子类 undergraduate,其不仅具有父类的成员变量

    name(姓名)、number(学号),还定义了新成员变量academy(学院)、department

    (系)。在程序中调用父类的 print 方法。

    编写 Undergraduate 程序:

    class Undergraduate extends Student

    {

    【代码1】 //定义成员变量academy

    【代码2】 //定义成员变量department

    public static void main(String args[])

    {

    【代码3】 //创建一个学生对象s

    【代码4】 //用父类的setData方法初始化对象s

    【代码5】 //对象s调用print方法

    【代码6】 //创建一个大学生对象u

    【代码7】//调用父类的成员方法setData初始化对象u

    【代码8】 //设置对象u的成员变量academy

    【代码9】 //设置对象u的成员变量department

    System.out.print(u.name+", "+u.number+", "+u.academy+", "+u.department);

    }

    }

    (3)编译并运行程序

    注意:公共类 Student 与undergraduate 类要在同一文件夹(路径)内。

    (二)方法的重载

    (1)程序功能:对不同的数进行排序输出。在IntSort 类中定义3 个同名的方法sort。

    (2)编写Sort.java 文件,源代码如下。

    import java.awt.Graphics;

    import java.applet.Applet;

    class IntSort {

    public String sort(int a, int b) {

    if (a>b)

    return a+""+b;

    else

    return b+""+a;

    }

    public String sort(int a, int b, int c) {

    int swap;

    if (a

    swap=a;

    a=b;

    b=swap;

    }

    if (a

    swap=a;

    a=c;

    c=swap;

    }

    54

    if (b

    swap=b;

    b=c;

    c=swap;

    }

    return a+""+b+""+c;

    }

    pub

    展开全文
  • JAVA 继承与多态

    2020-03-27 11:46:45
    当一个类有很多子类时,并且这些子类都重写了父类中的某个方法,那么当把子类创建的对象的引用放到一个父类的对象中时,就得到了该对象的一个上转型对象,那么这个上转型...package 继承与多态; public class Anima...

    当一个类有很多子类时,并且这些子类都重写了父类中的某个方法,那么当把子类创建的对象的引用放到一个父类的对象中时,就得到了该对象的一个上转型对象,那么这个上转型对象在调用这个方法时就可能具有多种形态,因为不同的子类在重写父类的方法时可能产生不同的行为。
    多态性就是指父类的某个方法被其子类重写时,可以各子产生自己的功能行为。
    举例:

    package 继承与多态;
    
    public class Animal {
        void cry() {
        	
        }
    }
    class Dog extends Animal{
    	void cry() {
    		System.out.println("汪汪......");
    	}
    }
    class Cat extends Animal{
    	void cry() {
    		System.out.println("喵喵......");
    	}
    }
    
    
    package 继承与多态;
    
    public class Test {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
              Animal animal;
             animal=new Dog();
             animal.cry();
             animal=new Cat();
             animal.cry();
    	}
    
    }
    
    

    在这里插入图片描述

    展开全文
  • 1. 继承1.1 super的用法在Java中,任何class的构造方法,第一行语句必须是调用父类的构造方法。如果没有明确地调用父类的构造方法,编译器会帮我们自动加一句super()。下面代码定义了人和学生类的继承关系:class ...

    1. 继承

    1.1 super的用法

    在Java中,任何class的构造方法,第一行语句必须是调用父类的构造方法。

    如果没有明确地调用父类的构造方法,编译器会帮我们自动加一句super()。

    下面代码定义了人和学生类的继承关系:

    class Person {

    String name;

    int age;

    public Person(String name, int age) {

    this.name = name;

    this.age = age;

    }

    }

    class Student extends Person {

    int score;

    public Student(String name, int age, int score) {

    this.score = score;

    }

    }

    public class Main {

    public static void main(String[] args) {

    // 程序将报错

    Student s = new Student("phonyhao", 23, 95);

    }

    }

    但是实际运行时会报错,Student构造函数由于没有调用父类的构造函数,编译器将自动生成一个super(),如下:

    public Student(String name, int age, int score) {

    super();

    this.score = score;

    }

    但是,Person我们已经定义了有参构造函数,那么默认构造函数将不会自动产生,因此Student类的构造函数调用super()会因为找不到合适的构造函数而报错。

    代码应修改如下:

    public Student(String name, int age, int score) {

    super(name, age);

    this.score = score;

    }

    1.2 向下转型

    下面代码将报错

    Person p1 = new Student(); // upcasting, ok

    Person p2 = new Person();

    Student s1 = (Student) p1; // ok

    Student s2 = (Student) p2; // runtime error! ClassCastException!

    p1实际类型为Student,所以通知强制类型转换为Student将不会报错。

    p2实际类型为Person,子类比父类多一些字段和方法,所以p2不能凭空多出来这些方法而变成Student的实例。

    由于直接强制转换及其容易产生异常,所以需要先使用instanceof关键字判断:

    if (p1 instanceof Student) { // true

    Student s1 = (Student) p1;

    }

    if (p2 instanceof Student) { // false

    Student s2 = (Student) p2;

    }

    2. 多态

    2.1 重载与重写的区别

    在继承关系中,子类和父类如果定义了两个方法签名完全相同:

    方法名

    参数类型

    参数个数

    返回值类型

    的两个方法,则子类的这个方法被称为重写了父类的方法。

    例如,在Person类中定义了run()方法:

    class Person {

    public void run() {

    System.out.println("Person.run");

    }

    }

    在子类Student中,重写这个run()方法:

    class Student extends Person {

    @Override

    public void run() {

    System.out.println("Student.run");

    }

    }

    只要两个方法签名不完全相同,则被称为重载。

    重写必须体现至父子类关系中以实现多态,而重载写在哪都可以。

    那想调用父类被重写的方法怎么办呢?使用super来帮忙。

    class Student extends Person {

    @Override

    public void run() {

    super.run(); // Person.run

    System.out.println("Student.run");

    }

    }

    2.2 final关键字

    final修饰的方法可以阻止被覆写;

    final修饰的class可以阻止被继承;

    final修饰的field必须在创建对象时初始化,随后不可修改。

    展开全文
  • JAVA继承与多态

    2018-02-18 19:24:10
    java中的多继承仅适用于接口,类没有多继承,只有单继承 为什么java没有多继承??? 多层继承时,有参无参构造函数的调用顺序? 若父类和子类的构造方法实际参数列表和参数列表长度不同,同时也没有使用super访问...
  • package sample; public class student extends person{ public student(String a,int b) { super(a,b); } public void work() { System.out.println(this.name+"学习"); } }
  • java 继承与多态

    2016-04-22 20:45:26
    继承与多态 继承一般是指晚辈从父辈那里继承财产,也可以说是子女拥有父母所给予他们的东西。 在面向对象程序设计中,继承的含义与此类似,所不同的是,这里继承的实体是类。也就是说继承是子类拥有父类的成员。 ...
  • 问题1:继承条件下的构造方法调用?通过super语句调用父类方法super()或super(参数)但父类构造方法必须在子类构造方法中是第一个语句。问题2:为什么子类的构造方法在运行之前,必须调用父类的构造方法?能不能反...
  • 主要介绍了Java 继承与多态的深入理解的相关资料,子类继承父类的特征和行为,使得子类具有父类的各种属性和方法。或子类从父类继承方法,使得子类具有父类相同的行为,需要的朋友可以参考下
  • 而面向对象的基本特性就是封装、继承与多态。一、继承extends 关键字表示继承某个已存在的类,已存在的类称为“超类”、“基类”、或“父类”,而新继承的类称为“子类”、“派生类”。子类可以方...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,602
精华内容 3,840
关键字:

java继承与多态

java 订阅