精华内容
下载资源
问答
  • 在Idea中直接Ctrl + t 查看类的子类是可以看到,但是他没有那种层级顺序! 我们可以在类中点击顶部菜单 Navigate -----> Type Hierarchy 或者 按F4 你会像下面一样,获得一个有层级关系的子类关系列表,跟...

    在Idea中直接Ctrl + t 查看类的子类是可以看到,但是他没有那种层级顺序!

    我们可以在类中点击顶部菜单
    Navigate -----> Type Hierarchy
    或者 按F4
    你会像下面一样,获得一个有层级关系的子类关系列表,跟eclipse中一样!
    在这里插入图片描述

    经过一些评论,我想说如下几点:
    1、如果你的快捷键方式不是 eclipse的,那么请你在顶部菜单 Navigate -----> Type Hierarchy 看看你自己的快捷键方式所对应的快捷键。
    在这里插入图片描述
    2、多思考,一个 idea 的使用未必能够误人子弟。
    3、我写博客也没有关乎利益,还会被挨打?希望有些人评论的时候带点脑袋!

    展开全文
  • java的父类声明new子类对象 和子类声明new子类对象

    千次阅读 多人点赞 2018-04-28 16:26:01
    父类名 a = new 子类名()子类名 b = new 子类名()a只能调用父类的函数,不能调用子类的函数,因为它没有继承b可以调用父类的函数也可以调用子类的函数但是对构造函数的执行上二者是没有区别的。...

    父类名 a = new 子类名()

    子类名 b = new 子类名()


    a只能调用父类的函数,不能调用子类的函数,因为它没有继承

    b可以调用父类的函数也可以调用子类的函数

    但是对构造函数的执行上二者是没有区别的。

    展开全文
  • 父类 子类

    千次阅读 2019-10-04 19:14:03
    如果一个派生类的派生符是public 则 ,将基类称为 父类,派生类称为子类, C++ 允许,父类的指针直接指向子类的对象,或者父类引用子类: #include<iostream> #include<stdio.h> #include<...

     如果一个派生类的派生符是public 则 ,将基类称为 父类,派生类称为子类,

    C++ 允许,父类的指针直接指向子类的对象,或者父类引用子类:

     

    #include<iostream>
    #include<stdio.h>
    #include<stdlib.h>
    using namespace std;
    class point{
         int x;
         int y;
         public:
         point(int x,int y):x(x),y(y){}
       void  show(){ cout<<"point"<<endl;}
         };
    class circle:public point{
         int r;
         public:
         void show(){ cout<<"circle"<<endl;}
         circle(int x,int y,int r):point(x,y),r(r){}
         };
    int main()
    {
         circle c(1,2,3);
         point * p=&c;
         c.show();
         p->show();
         system("pause");
         return 0;
         }

     

     如果一个函数被声明为基类的友元,则该友元内部的基类指针,也可以指向派生类的对象,即

     对于基类的友元而言,在友元内部,基类被当做父类。

     

    #include<iostream>
    #include<stdio.h>
    #include<stdlib.h>
    using namespace std;
    class point{
         int x;
         int y;
         public:
         point(int x,int y):x(x),y(y){}
         void  show(){ cout<<"point"<<endl;}
         friend void f1();
         void f2();
         };
    class circle:point{
         int r;
         public:
         void show(){ cout<<"circle"<<endl;}
         circle(int x,int y,int r):point(x,y),r(r){}
         };
    circle c(1,2,3);
    void f1()
    {
        point *p=&c;
        p->show();
    }
    
    /*void f2()
    {
        point *p=&c;//f2不能访问
        p->show();
    }  */
    int main()
    {
    
         f1();
         //f2(); f2不能访问
    system("pause"); return 0; }

     

    做个补充:父子类可以做下面这四件事(和上面的第一个冲突):

     1:子类的对象可以给父类赋值。 赋值效果,基类数据成员和派生类中数据成员的值相同

     2:子类的对象可以初始化父类的引用

     3:父类的指针可以指向子类的地址

     4:函数的参数是父类的引用时,当函数调用时,可以将子类的对象作为实参

     

      

    #include<iostream>
    #include<stdio.h>
    #include<string>
    #include<stdlib.h>
    using namespace std;
    class base{
        string name;
        public:
        void show();
        base(string name):name(name){}
    };
    void base::show()
    {
        cout<<"base->"<<base::name<<endl;
    }
    class son:public base{
         public:
         void show();
         son(string name):base(name){}
    };
    void son::show()
    {
        cout<<"son"<<endl;
    }
    void f(base & fa)
    {
         fa.show();
    }
    int main()
    {
        son a("guo");
        a.show();
        base b(a);
        b.show();
        //son c(b);
    
    
        base & c=a;
        c.show();
    
    
        base * d=&a;
        d->show();
    
        f(a);
        system("pause");
    }

     

    转载于:https://www.cnblogs.com/cs1003/archive/2012/12/19/2825453.html

    展开全文
  • 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

    展开全文
  • dedecms列表页,栏目有子类就显示出子类,没有子类显示空,我们在使用织梦列表页的时候,比如有两个栏目:产品中心、成功案例,他们共用list_image.htm模板,产品中心有子类产品一、产品二、产品三等,而成功案例...
  • Java 子类 instanceof 父类

    万次阅读 2018-08-16 14:26:31
    子类 instanceof 父类 == true 父类 instanceof 子类 == false 2.测试代码 @Test public void testInstanceof() { // 子类 instanceof 父类 ConsultSmsPatientDataBO sub = new ConsultSmsPatientD...
  • Collection子类

    千次阅读 2018-07-25 14:45:48
    Collections的子类:  List:1.可以允许重复的对象。  2.可以插入多个null元素。  3.是一个有序容器,保持了每个元素的插入顺序,输出的顺序就是插入的顺序。  4.常用的实现类有 ArrayList、LinkedList 和 Vector...
  • !... 我现在有这几个类,A B1 B2是接口,A是B1 B2的父类,B1 B2是C1 C2父类, 现在我用A a = new C1(); (a as C1).... 可以调用子类方法。如果父类不转为子类,还有什么方法父类可以访问到子类的方法。
  • 假设有一个子类和一个父类, 父类 dad = new 子类(); 这时dad不能调用子类独有的方法,只能调用子类重写了父类的方法 但是为什么可以在子类重写父类的方法中调用子类独有的方法 ``` public class Dad { ...
  • c++ 子类构造函数初始化及父类构造初始化

    万次阅读 多人点赞 2018-08-30 15:58:50
    我们知道,构造方法是用来初始化类对象的。如果在类中没有显式地声明构造函数,那么编译器会自动创建一个默认的构造函数;并且这个默认的构造函数仅仅在没有显式地声明构造函数的...如果子类的构造函数没有显示地调...
  • 请问下java.sql下PreparedStatement中的setClob(int parameterIndex, Reader reader)方法中Reader reader类型为什么...FileReader并不是Reader的子类,而是它子类子类;难道说形参内可以传入子类子类对象吗?谢谢
  • 父类子类转换

    2019-09-26 14:44:56
    子类转父类: 让父类的引用指向子类的引用就可以转换。除了构造方法以外子类继承了父类的所有,所以父类指向子类是没问题的。 Son s = new Son(); Father f = s; 上段代码中s是子类的引用,f是父类的引用,...
  • C++ 子类转父类 父类确定子类

    千次阅读 2016-10-01 18:38:26
    将一个结构体转换为字节数组,再讲字节数组还原成结构体,子类转换为父类,通过父类信息确定是哪个子类转换的父类
  • Spring 子类注入

    千次阅读 2019-04-21 15:57:21
    一个父类接口,三个子类接口,一个子类子类接口 public interface FatherInterface {} public class InterfaceOne implements FatherInterface{} public class InterfaceThree implements FatherInterface{}...
  • 子类与继承

    千次阅读 2018-12-10 21:16:26
    一、子类与父类 object类是所有类的祖先类。 1、子类与继承 (1)关键字:extends class 子类名 extends 父类名{···} (2)继承特性:java不支持多继承,一个子类只能有一个父类 同一包中:不继承private...
  • A派生出子类B,B派生出子类C,并且在java源代码中有如下声明: 1 2 3 A a0=new A(); A a1=new B(); A a2=new C(); 以哪个说法是正确的 A第1行,第2行和第3行的声明都是正确...
  • 1、利用继承这个机制,可以先定义一个共有属性的一般类,根据这个类再分别定义具有特殊属性的子类子类继承了一般类的属性和方法,并根据自己的需求创建新的属性和方法; 2、使用Java关键字 extends 来定义一个类...
  • 子类继承父类,重载了父类方法。面试中经常考到方法的调用,以及构造函数先后顺序。 例子 定义父类,申明方法say() public class TestParent { protected static String name = "parent"; TestParent(){ say(); ...
  • c++父类和子类

    千次阅读 2019-05-30 21:56:15
    父类和子类的关系 子类继承父类的所有属性和行为; 子类可以定义自己的属性和行为; 父类和子类的继承 在类中,变量有三种属性,分别为public,protectd,private; 其区别如下: 变量属性 说明 public 可以...
  • 子类继承父类的时候,子类的构造函数怎么写 构造函数用于构造一个类,是不能继承,不能被覆盖的。 (1)父类显式定义有参构造函数,而没有定义无参构造函数的时候,java虚拟机默认不自动创建一个无参构造函数。 (2...
  • 例如父类Person指向子类Student:Person p = new Student(); 父类类型实例p可以调用父类中定义的所有属性和方法,而对于子类中定义而父类中没有的方法,它是无可奈何的; 同时,父类中的一个方法只有在在父类中定义...
  • 有这样的结构设计类: ...基本的描述就是,子类和父类的名称属性名称都一样, 这样的话,子类spring注入的时候,不会把自己类中对应的属性自动注入。 求这样的子类父类同名、属性也同名的解决方案。
  • layer.open 调用子类窗口方法, 子类调用父类方法 <!-- 父类 --> var index = layer.open({ type : 2, title : title, shadeClose : true, shade : 0.8, ...
  • 子类继承方式 public protected private 父类成员属性 public public protected private protected protected protected private private 不可...
  • Java 中父类怎么调用子类的方法?

    万次阅读 2016-10-24 22:41:38
    父类能调用子类的方法吗? 答:能。 怎么做? ● 把子类传递到父类的有参构造中,然后调用。● 使用反射的方式调用,你使用了反射还有谁不能调用的?! ● 父类调用子类的静态方法。 案例展示: package ...
  • 但是 需求 是,必须要父类的对象,不能是子类对象, 那么 只能一个个的把子类的值 赋值 给 父类吗 有没有什么便捷的方法,因为 属性 太多了 求解答 ,谢谢!
  • 不能,你不能在Java中覆盖静态方法,但你可以在子类中声明一个完全相同的方法,不会产生编译错误,这称为隐藏在Java中的方法。 你不能覆盖Java中的静态方法,因为方法覆盖基于运行时的动态绑定,静态方法在编译时...
  • 重写是继承的时候,重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。 重载,是在一个类里面,方法名字相同,而参数不同。返回类型可以相同也可以不同。重载可以避免使用完全不同...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 208,878
精华内容 83,551
关键字:

子类