精华内容
下载资源
问答
  • java子类重写父类方法,跟子类自己重新定义一个方法有什么区别? 最好贴上代码讲解一下
  • java子类继承父类、方法的重写(覆盖)   在程序中,如果想声明一个类继承另一个类,需要使用extends关键字。 格式: class 子类 extends 父类 {} public class Text { public static void main (String[]...

     java子类继承父类、方法的重写(覆盖)

     

    在程序中,如果想声明一个类继承另一个类,需要使用extends关键字。

    格式:

    class 子类 extends 父类 {}

    
    
    public class Text {
    	public static void main (String[] args) {
    		new newPhone().showNum();
    	}
    }
    //父类 手机
    class Phone{
    	public void sendMessage() {
    		System.out.println("发短信");
    	}
    	public void call() {
    		System.out.println("打电话");
    	}
    	public void showNum() {
    		System.out.println("显示来电号码");
    	}
    }
    //子类 新手机类
    class newPhone extends Phone{
    	//覆盖父类的来电显示号码功能,并增加自己的显示姓名和图片功能
    	public void showNum() {
    		//调用父类已经存在的功能使用super
    		super.showNum();
    		//增加自己特有显示姓名和头像功能
    		System.out.println("显示姓名");
    		System.out.println("显示头像");
    	}
    } 

     

    展开全文
  • Java子类调用父类构造方法

    万次阅读 多人点赞 2017-09-29 14:49:15
    Java中,子类的构造过程中,必须调用其父类的构造函数,是因为有继承关系存在时,子类要把父类的内容继承下来,通过什么手段做到的?   答案如下:   当你new一个子类对象的时候,必须首先要new一个父类...

    在Java中,子类的构造过程中,必须调用其父类的构造函数,是因为有继承关系存在时,子类要把父类的内容继承下来,通过什么手段做到的?    

       答案如下:    

        当你new一个子类对象的时候,必须首先要new一个父类的对像出来,这个父类对象位于子类对象的内部,所以说,子类对象比父类对象大,子类对象里面包含了一个父类的对象,这是内存中真实的情况.构造方法是new一个对象的时候,必须要调的方法,这是规定,要new父类对象出来,那么肯定要调用其构造方法,所以:    

         第一个规则:子类的构造过程中,必须调用其父类的构造方法。一个类,如果我们不写构造方法,那么编译器会帮我们加上一个默认的构造方法,所谓默认的构造方法,就是没有参数的构造方法,但是如果你自己写了构造方法,那么编译器就不会给你添加了,所以有时候当你new一个子类对象的时候,肯定调用了子类的构造方法,但是在子类构造方法中我们并没有显示的调用基类的构造方法,就是没写,如:super(); 并没有这样写,但是这样就会调用父类没有参数的构造方法,如果父类中没有没有参数的构造方法就会出错。    

         第二个规则:如果子类的构造方法中没有显示的调用基类构造方法,则系统默认调用基类无参数的构造方法注意:如果子类的构造方法中既没有显示的调用基类构造方法,而基类中又没有默认无参的构造方法,则编译出错,所以,通常我们需要显示的:super(参数列表),来调用父类有参数的构造函数。

      

    复制代码
     1 //当你没有使用父类默认的构造方法时,此时在子类的构造方法中就需要显示的调用父类定义的构造方法。
     2 class Animal{
     3   private String name;
     4   
     5   //如果你定义一个新的构造方法
     6   public Animal(String name) {
     7     this.name = name;
     8   }
     9 }
    10 
    11 public Dog extends Animal{
    12   
    13   //这时你就要显示的调用父类的构造方法,因为子类默认调用的是父类的
    14   //无参构造方法Animal()
    15   public Dog(){
    16     super("小狗");  //显示调用父类的有参构造方法
    17 
    18     ....  //子类的构造方法处理
    19   }
    20 }
    21 
    22 //当然,如果你在父类里面把无参的构造方法,显示的写出来了,比如:
    23 class Animal{
    24   private String name;
    25 
    26   //无参的构造方法
    27   public Animal() {
    28     .....  //处理
    29   }
    30   
    31   /*
    32   如果你定义一个新的构造方法,那么在子类的构造方法中,就可以不用显示的调用父类的构造方法,因为子类有个无参的构造方法,
    33   子类在构造方法中会自动调用父类已经定义的无参构造方法。
    34   */
    35   public Animal(String name) {
    36     this.name = name;
    37   }
    38 }
    复制代码

    总结:不过一般的,在父类中使用了构造方法的重载,在子类中就可以根据需要,调用相应的父类构造方法。

    展开全文
  • 用学生的输出为例子,子类继承父类,然后在子类中新定义一个属性并可以给父类属性赋值,以及重写tostring和重写equals方法。 demo测试 package Student; public class demo { public static void main(String[] ...

    用学生的输出为例子,子类继承父类,然后在子类中新定义一个属性并可以给父类属性赋值,以及重写tostring和重写equals方法。
    在这里插入图片描述
    demo测试

    package Student;
    
    public class demo {
    
        public static void main(String[] args) {
    	// TODO Auto-generated method stub
    
    	Undergraduate s1 = new Undergraduate("张三", 30, "专科");
    
    	Undergraduate s2 = new Undergraduate("张三", 30, "本科");
    	Undergraduate s3 = new Undergraduate("张三", 30, "本科");
    	System.out.println(s1.equals(s2));
    	System.out.println(s3.equals(s2));
    	System.out.println(s1);
    	System.out.println(s2);
    	System.out.println(s3);
    
        }
    
    }
    
    

    父类定义属性

    package Student;
    
    public class Student {
        public String name;
        public int age;
    
        public Student() {
    	// TODO Auto-generated constructor stub
        }
    
        public Student(String name, int age) {
    	this.name = name;
    	this.age = age;
        }
    
        public void show() {
    	System.out.println(name + "," + age);
    
        }
    
    }
    
    

    子类定义新属性,重写函数

    package Student;
    
    public class Undergraduate extends Student {
        public String degrre;
    
        public Undergraduate(String name, int age, String degrre) {
    	super(name, age);
    	this.degrre = degrre;
        }
    
        @Override
        public int hashCode() {
    	final int prime = 31;
    	int result = 1;
    	result = prime * result + ((degrre == null) ? 0 : degrre.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;
    	Undergraduate other = (Undergraduate) obj;
    	if (degrre == null) {
    	    if (other.degrre != null)
    		return false;
    	} else if (!degrre.equals(other.degrre))
    	    return false;
    	return true;
        }
    
        @Override
        public String toString() {
    	return "degrre=" + degrre + ", name=" + name + ", age=" + age + "";
        }
    
        public void show() {
    	System.out.println(name + "," + degrre + "," + age);
    
        }
    }
    

    运行结果展示
    在这里插入图片描述

    展开全文
  • java父类获取子类对象、调用子类方法

    万次阅读 多人点赞 2020-01-17 14:24:39
    1.Java中父类能调用子类方法吗? 答案:能 1.1 实现方式描述 (1)父类中的抽象方法子类实现并返回 (2)通过注册监听,然后通过回调接口调用子类相关方法 (3)在父类中通过反射调用子类的相关方法 (4)在...

    1.Java中父类能调用子类的方法吗?

    答案:能

    1.1 实现方式描述

    (1)父类中的抽象方法让子类实现并返回
    (2)通过注册监听,然后通过回调接口调用子类相关方法
    (3)在父类中通过反射调用子类的相关方法
    (4)在父类中直接new子类相关对象或者通过构造函数传入子类对象,然后调用其方法
    (5)将子类相关方法声明为static,在父类中调用子类的static方法

     

    1.2 四种实现方式的代码

    方式一:父类中的抽象方法,子类继承父类并实现抽象方法,有返回值,父类就可以拿到子类中的对象或者调用子类的方法。

    父类抽象方法:

    public abstract class Father {
    
    	protected abstract int getSonData();
    
    	// 父类调用子类方法
    	public int getData() {
    		return getSonData();
    	}
    
    }

    子类继承父类并实现抽象方法:

    public class Son extends Father {
    
    	private int sonData = 100;
    
    	// 子类实现的父类方法
    	@Override
    	protected int getSonData() {
    		return sonData;
    	}
    
    }

    测试:

    public class Test {
    	public static void main(String[] args) {
    		Father father = new Son();
    		int sonData = father.getData();
    		System.out.println("获取子类数据:" + sonData);
    	}
    }

    结果:

    获取子类数据:100

    方拾二:子类利用接口回调提供给父类数据

    父类的接口:

    public class Father {
    	
    	private CallBackListener cBackListener;
    
    	public void setListener(CallBackListener listener) {
    		this.cBackListener = listener;
    	}
    	
    	//父类调用子类方法
    	public int getSonData() {
    		return cBackListener.sonData();
    	}
    
    }
    
    interface CallBackListener {
    	int sonData();
    }

    子类实现父类接口:

    public class Son extends Father implements CallBackListener{
    	
    	public void getFather() {
    		setListener(this);
    	}
    	
    
    	//子类实现父类方法
    	@Override
    	public int sonData() {
    		return 2020;
    	}
    
    }
    

    测试:

    public class Test {
    	public static void main(String[] args) {
    		Son son = new Son();
    		son.getFather();
    		int data = son.getSonData();
    		System.out.println("从父类获取的子类数据:" + data);
    	}
    }

    结果:

    从父类获取的子类数据:2020

    方式三、四、五:Son只提供打印方法,Father中通过这三种方式都可以获取到Son的实例对象,就可以完成在父类中调用子类的方法:

    子类:

    public class Son extends Father{
    
    	public void test(String test) {
    		System.out.println(test);
    	}
    	
    	public static void testStatic() {
    		System.out.println("static test");
    	}
    }

    父类:

    public class Father {
    
    	/**
    	 * 通过new son() 直接获取子类实例
    	 */
    	public void callSonMethod_newSon() {
    		Son son = new Son();
    		son.test("通过new Son()获取子类实例");
    	}
    
    	/**
    	 * 通过反射获取子类实例
    	 */
    	public void callSonMethod_reflection() {
    		try {
    			Class clazz = Class.forName("other.Son");
    			Son son = (Son) clazz.newInstance();
    			son.test("通过反射获取子类实例");
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    
    	}
    
    	/**
    	 * 通过静态变量获取子类实例
    	 */
    	public void callSonMethod_static() {
    		Son.testStatic();
    	}
    
    }
    

    测试:

    public class test {
    	public static void main(String[] args) {
    		Father father = new Father();
    		father.callSonMethod_newSon();
    		father.callSonMethod_reflection();
    		father.callSonMethod_static();
    	}
    }

    结果:

    通过new Son()获取子类实例
    通过反射获取子类实例
    static test

    2.上述几种实现方式,在实际项目被允许吗?

    如果各位看官细细品味了上面的样例代码,并且稍微熟悉面向对象的继承和多态特性的话,会得出一个显而易见的结论,不允许
    看到这儿,如果仍有看官,不太明白为什么不允许话,小编只能在上面的样例基础上,简单提醒以下几点,还需各位看官在实际项目研发过程中细细品味 & 时常总结,敬请见谅。因为毕竟涉及到面向对象的基本属性、项目经验,有些东西本来就是约定、规则、经验,无法进行明说。

    (1)Java继承概念中,父类是不确定子类的,但子类可以确定其父类--多态特性的来源之一
    (2)父类是不可调用子类的方法的,但子类可以调用父类所有非private的方法-继承特性的特征之一
    (3)存在明显的代码漏洞,例如:因为Java继承的关系,所以类进行加载时,是先加载的父类,才去加载子类,如果恰巧这是父类的某个方法调用了子类的方法,而子类方法的某些常量因为子类还未加载没有实例化,就会直接导致程序崩溃
    (4)如果通过上述方法实现了相关效果,那么请这样做的各位Coder反思一个问题,您的子类继承父类的意义到底在哪里?

    3.如果在实际项目中,的确有这样的特殊业务场景,即有些实现并不确定,需要具体子类去实现,但是又必须在父类规定其调用顺序与场景,应如何做?

     

    package test;
    
    /**
     * 父类
     */
    public abstract class Father {
        // 基本方法
        protected abstract void doSomething();
    
        // 基本方法
        protected abstract void doAnything();
    
        // 模板方法
        public void templateMethod() {
            /*
             * 调用基本方法,完成相关的逻辑
             */
            this.doAnything();
            this.doSomething();
        }
    }
    
    

     

    package test;
    
    
    /**
     * 子类
     */
    public class Son extends Father{
    
        @Override
        protected void doSomething() {
            System.out.println("Son doSomething");
        }
    
        @Override
        protected void doAnything() {
            System.out.println("Son doAnything");
        }
    
        
    }
    
    

     

    package test;
    
    /**
     * 测试功能类
     * 
     */
    public class TestTwo {
        public static void main(String[] args) {
            Son son = new Son();
            son.templateMethod();
        }
    }
    

    基本方法:基本方法也叫做基本操作,是由子类实现的方法,并且在模板方法中被调用。
    模板方法:可以有一个或者几个,一般是具体的方法,也就是一个框架,实现对基本方法的调度,完成固定的逻辑。

    优点:
    ● 封装不变部分,扩展可变部分
    ● 提取公共部分代码,便于维护
    ● 行为由父类控制,子类实现

    缺点:
    按照我们的设计习惯,抽象类负责声明最抽象、最一般的事物属性和方法,实现类完成具体的事物属性和方法。但是模板方法模式却颠倒了,抽象类定义了部分抽象方法,由子类实现,子类执行的结果影响了父类的结果,也就是子类对父类产生了影响,这在复杂的项目中,会带来代码阅读的难度,而且也会让新手产生不适感。

    参考: https://www.jianshu.com/p/204e5d76ec11

    展开全文
  • 指的是:子类中出现了和父类一模一样的方法时,子类重写父类的方法 Java中重载 重载:Overload 指的是一个类中的同名方法,参数列表不同,返回值可能也不同。 区别 重写必须发生在两个类之间,子类和父类,...
  • Java子类继承父类

    千次阅读 2015-08-07 15:57:30
    2.在子类中,可以使用父类中“public”和“protected”定义方法和属性,也可以创建的数据和方法;没有访问“private”定义方法和属性的权限。 protected的使用方式: /** * Person.java */ package ...
  • Java子类与继承

    千次阅读 2016-02-02 11:16:00
    根据该一般类再定义具有特殊属性的子类子类继承一般类的属性和行为,并根据需要增加它自己的属性和行为。 例子: class 子类名 extends 父类名 { } class Student extends People { }
  • 看以下代码:父类使用private定义方法子类使用public覆写: class Father{ public void fun(){ this.print(); } //如果现在父类使用了private定义,那么就表示该方法只能被父类使用,子类无法使用,...
  • 1,上篇说子类可以继承父类的成员变量,作为自己的成员变量,在Java中子类也可以隐藏由父类继承来的成员变量,只要子类中声明的成员变量和父类的成员变量同名,就可以将其隐藏。 需要的注意是:子类对象可以调用从...
  • Java子类与继承(完整版)】

    千次阅读 多人点赞 2021-03-25 22:53:12
    Java子类与继承1 子类与父类1.1 子类1.2 类的树形结构2 子类的继承性2.1 子类和父类在同一包中的继承性2.2 子类和父类不在同一包中的继承性2.3 继承关系(Generalization)的UML图2.4 protected的进一步说明3 子类与...
  • (1)父类显式定义有参构造函数,而没有定义无参构造函数的时候,java虚拟机默认不自动创建一个无参构造函数。 (2)如果父类显式的添加无参构造函数,则子类可以创建自己的有参或无参构造函数,如果子类没有显示...
  • Java_数组定义及常用方法

    万次阅读 2013-12-12 22:37:15
    Java_数组定义及常用方法 摘要:  从数组的一些简单介绍、到定义、声明、初始化、以及常用的方法、细微的区别、但是没有讲多维数组、多维数组本质是一维数组的延伸、以后有时间补充、有补充或者误导的...
  • Java父类和子类的关系

    千次阅读 2018-02-12 14:36:22
    子类覆盖了某方法,则父类引用调用子类重新定义新方法子类未覆盖某方法,则父类引用调用父类本身的旧方法 若子类覆盖了某属性,但父类引用仍调用父类本身的旧属性 若子类未覆盖某属性,则父类引用调用父类...
  • [Java]子类不继承父类私有方法

    千次阅读 2018-12-26 21:18:50
    子类不继承父类私有的方法, 更无法重写父类私有的方法。 关于子类是否继承父类私有的方法和属性这个问题,有看到回答继承的,也有看到回答不继承的。一直找不到一个合适的方法测试,所以只能是相信书上说的“获得...
  • 1、子类对象以及子类自己定义方法操作与父类同名的成员变量是指子类重新声明的这个成员变量 2、子类继承的方法所操作的成员变量一定是被子类继承或隐藏的成员变量 3、子类仍然可以调用从父类继承的方法操作子类...
  • Java子类与父类之间的对象转换(说明继承)

    万次阅读 多人点赞 2018-04-24 22:57:12
    在使用Java的多态机制时,常常使用的一个特性便是子类和父类之间的对象转换。从子类向父类的转换称为向上转换(upcasting),通过向上转换,我们能够在编写程序时采用通用程序设计的思想,在需要使用子类对象的时候...
  • (易混点)java中,关于子类继承父类的private方法与final方法 对于子类继承父类的方法,相信很多人都已经掌握得非常熟悉了,今天由于在做牛客网的一道关于这个知识点的面试题,忽略了一个非常重要的细节,导致入坑...
  • 返回本章节 返回作业目录 需求说明: 在子类老虎中重写父类动物的吃食方法 实现思路: ... 在Tigger类新定义action()方法,通过super关键字,调用父类本身的eat()行为。 实现代码: ...
  • 子类见不到父类的私有方法,如果定义一个和父类中私有方法同名的方法,则不是覆盖。是个新方法
  • java1.8特性之接口定义增强

    千次阅读 2017-05-11 14:11:34
    本篇重点:使用default和static定义接口方法java发展之初到今天已经经过了20年的时间了,在这20年的时间里所有的java开发者都知道java中的接口是由全局常量和抽象方法组成。但是从jdk1.8的时代这一组成改变了。为...
  • 也许你已经熟练使用了java.util包里面的各种数据结构,但是我还是要说一说java版数据结构与算法,希望对你有帮助。 线性表,链表,哈希表是常用的数据结构,在进行Java开发时,JDK已经为我们提供了一系列相应的类来...
  • 子类和父类定义相同的方法只要符合方法覆盖的条件: 子类和父类定义相同属性不会产生覆盖: 解析: 这个问题不仅要考虑变量、静态变量和常量三种情况,还要考虑private、friendly(即不加访问...
  • 子类继承父类中,子类重新定义父类中的同名方法,其实就是对父类方法的重写,所以是可以的。例如:public class a { public void x(){ System.out.println(1); } }public class b extends a { public void ...
  • 这个涉及到了java的多态中的向上转型,简单来说,父类引用生成子类对象,那这个引用只能调用在父类中已经定义过的属性和方法,而对子类自己新定义的属性和方法则不能访问。比如你这里的A ab=new B();,ab是一个父类...
  • 子类覆盖父类方法

    千次阅读 2012-07-05 12:40:43
    如果父类方法是private,子类方法是public,这样是覆盖还是新定义方法? package com.subclassoverrideparent; import static java.lang.System.*;   public class Person {  private void fun(){   out...
  • 如题:new 一个没有构造方法子类,会调用父类的无参构造方法。如下面的两个类:
  • 详细解释Java中父类和子类的关系1 定义类2 构造方法3 成员变量4 成员方法5 类型转换6 隔代继承 主要包括:成员变量(覆盖)、构造方法、成员方法(覆盖)、类型转换 1 定义定义A、B、C、D四个类,B、C继承A,D继承B ...
  • 众所周知,java中this关键字指的是当前调用对象,一般使用方法不在此阐述public class HelloA { public static void main(String[] args) { new B().print(); } } class B extends A{ private String s = "B" ; ...
  • Java基础篇——类与子类

    千次阅读 2020-06-04 19:52:28
    继承就是子类继承父类的特征和行为,使得子类对象具有父类的实例域和方法,或子类从父类继承方法,获得等同于父类的相同行为的技术。java继承是面向对象的一个显著特征。 简单理解:类在生活中也是无处不在的,比如...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 251,651
精华内容 100,660
关键字:

java子类定义新方法

java 订阅