精华内容
下载资源
问答
  • 抽象类通过子类实例化

    千次阅读 2019-12-03 13:50:00
    抽象类其实是可以被实例化的,但是它的实例化方式并不是通过普通的new方式来创建对象,而是通过父类的应用来指向子类的实例间接地实现父类的实例化,因为子类实例化之前,一定会先实例化它的父类。这样创建了继承...

    抽象类其实是可以被实例化的,但是它的实例化方式并不是通过普通的new方式来创建对象,而是通过父类的应用来指向子类的实例间接地实现父类的实例化,因为子类在实例化之前,一定会先实例化它的父类。这样创建了继承抽象类的子类对象,也就把其父类(抽象类)给实例化了。

    注意:接口与抽象类非常类似,但是它不可以被实例化,因为接口压根没有构造函数。

    public abstract class B {
        private String str;
    
        public B() {
            System.out.println("父类已经实例化");
        }
    
        public B(String a) {
            this.str = a;
            System.out.println(str);
        }
    
        public abstract void play();
    }  

    然后,定义一个子类C去继承类B,并实现其中的抽象方法

    public class C extends B{  
        public C(String c){  
            System.out.println("子类已经被实例化");  
        }  
    
        @Override  
        public void play() {  
            System.out.println("我实现了父类的方法");  
        }  
    
        public static void main(String[] args){  
            B c = new C("c");  
        }  
    }  

    运行结果如下:

    父类已经实例化
    子类已经被实例化

     

    展开全文
  • 父类声明子类实例化对象详解

    千次阅读 2018-10-25 20:02:44
    总结:父类声明子类实例化产生的对象使用的是 子类 从父类继承的方法和属性。   原理: Employee A=new Manager(); 实际是父类句柄指向子类对象空间, 所以使用的属性和方法都是子类对象所有的 。而...

    测试代码:

    public class Employee {
    	public String name;
    	public String getType(){
    		return "Employee";
    	}
    	
    }
    public class Manager extends Employee{
    	private int money;
    	public String getType(){
    		return "Manager";
    	}
    }
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		Employee A=new Manager();
    		A.name="Tom";
    		//A.money=2;//报错
    		String Type=A.getType();
    		System.out.println(Type);//Manager
    	}
    

    通过测试我们发现以下几点:

    1. A对象可以使用从父类继承下来的非public属性
    2. A对象无法使用Manager子类新增的money属性
    3. A对象调用的方法是子类的方法

    总结:父类声明子类实例化产生的对象使用的是子类从父类继承的方法和属性。

     

    原理:

    Employee A=new Manager();

    实际是父类句柄指向子类对象空间,所以使用的属性和方法都是子类对象所有的。而因为是父类的句柄指向的只能是父类所拥有的属性和方法,所以指向的属性和方法实则又必须是是从父类继承而来的

    注意:

    不能用子类声明父类实例化对象!

    因为子类的句柄指向父类空间时,有可能有部分子类的属性方法是父类所没有的,因此,子类句柄无法指向有效的空间,编译无法通过。

     

     

    展开全文
  • 3.2、抽象一个实例化对象

    千次阅读 2018-03-28 19:20:36
    一、抽象一个 二、实例化对象 1、实例化对象 2、对象类型在内存中分配情况 三、$this 四、构造函数和析构函数

    一、抽象一个类
    所谓抽象一个类,就是怎么创建一个类。
    1、类的声明
    类的声明只需要使用关键字class,有时候需要在关键字前加上修饰类的关键字,如abstract或者final等,有时候还有Trait等关键字来取代class。声明格式如下:
    【修饰类的关键字】class 类名{
    类中成员
    }
    实例:eg:

    <?php
    class Base {
        public function sayHello() {
            echo 'Hello ';
        }
    }
    

    类名、变量名、函数名的命名规则,需要遵循PHP自定义名称的命名规则。如果由多个单词组成,习惯上每个单词的首字母要大写。
    2、类的成员属性
    类的成员属性声明,需要public,protected,private,static等关键字来修饰
    eg:

    <?php 
    
    class test 
    { 
        public $var1 = 1; 
        protected $var2 = 2; 
        private $var3 = 3; 
        static $var4 = 4; 
    } 
    

    3、类的成员方法
    类的成员方法声明和其属性类似,只是要加关键字function,也要有关键修饰词:public,protected 和 private等。
    eg:

    <?php
    class MyClass
    {
        private $foo = FALSE;
    
        public function __construct()
        {
            $this->$foo = TRUE;
    
            echo($this->$foo);
        }
    }
    

    二、实例化对象
    我们在创建类之后,并不是直接使用类,而是通过类来实例化出对象。
    1、实例化对象
    实例化对象需要使用的new关键字,一个类可以被实例化出多个对象,对象之间没有关联。
    eg:

    <?php
    	class MyClass
    	{
    	    private $foo = FALSE;
    	
    	    public function __construct()
    	    {
    	        $this->foo = TRUE;
    	
    	        echo($this->foo);
    	    }
    	}
    	
    	$bar = new MyClass();
    

    2、对象类型在内存中分配情况
    内存大体上被分为四段:
    1)栈空间段
    该空间段主要特点是:空间小,被访问速度快,后进先出(先进后出)。用于存储占用空间不变且占用空间小的数据类型的内存段。例如整型1、10、10000在内存中占用的空间是等长的,都是32位4字节。整型、double、boolean等类型都可以存储在栈空间段。
    2)堆空间段
    用于存储数据长度不定长,而且占用空间很大的数据类型的数据,例如字符串、数组、对象。该段是动态分配的。
    3)初始化数据段
    用于存放可执行文件中已初始化的全局变量,数据段存储经过初始化的全局和静态变量
    4)代码段
    存放可执行文件的操作指令,就是可执行程序在内存中的镜像。代码段需要防止在运行时被非法修改,所以只允许读取操作,不允许写入(修改)操作。例如程序中的函数就存储在该内存段中。
    其各段特点简要说明如下图:
    这里写图片描述

    实例说明:eg:

    <?php
    	class person{
    		public $name;
    		public $sex;
    		public function say(){
    			echo '666';
    		}
    	}
    	$p1 = new person();
    	$p2 = new person();
    	$p3 = new person();
    	/**$p1是第一个对象的引用变量(通过“=”把第一个对象的首地址"0xff001",赋值给了$p1),
    	 * 存放的是一个十六进制的整数被存放在栈内存中。相当于一个指针指向堆里边的对象。
    	 * 所以访问对象里边的成员都需要通过引用变量$p1
    	 */
    

    上段代码图形说明如下:
    这里写图片描述
    易混淆点:
    1、当将对象赋值给另一个变量时,此时是将对象的“首地址”赋值给了另一个变量,堆内的对象并没有复制一份。
    实例说明eg1:

    <?php
    	class test{
    		public $name;
    	}
    	$a = new test();
    	$b = $a;//这里与$b = &$a效果是一样的,仅针对对象
    	$b->name = 123;
    	var_dump($a->name);//输出123,说明只是将第一个对象的“首地址”赋值给了$b,改变的都是一个堆内的对象属性值
    	unset($a);
    	var_dump($b->name);//输出123,unset释放的只是第一个对象栈中的引用变量。
    	
    

    示例1说明图:
    这里写图片描述
    2、如果想得到一个对象的副本,用$a =clone $b; 用了clone后会产生一个新对象,分配内存,独立于原来的$a。
    eg2:

    <?php
    	class test{
    		public $name;
    	}
    	$a = new test();
    	$b = clone $a;
    	$b->name = 123;
    	var_dump($a->name);//输出null
    	unset($a);
    	var_dump($b->name);//输出123
    

    示例2图形说明:
    这里写图片描述

    3、当一个对象的引用断了的时候,这个对象在堆中就被当做垃圾,php就会执行垃圾回收机制,将这个对象回收,如图
    这里写图片描述
    4、栈内后进先出(先进后出)机制
    eg3:

    <?php
    class test  
    {  
        public $name;  
        //构造函数,当类被实例化时,会自动执行
        public function __construct($name)  
        { 
            $this -> name = $name;  
            echo $this->name."这里被执行了<br>";  
        }  
        public function __destruct()  
        {  
            echo $this->name."我被回收了<br>";  
        }  
    }
    $p1 = new test('王二');
    $p1 = 1;  
    $p2 = new test("张三");  
    $p3 = new test("李四");  
    /**输出 
     * 王二这里被执行了
     * 王二我被回收了
     * 张三这里被执行了 
     * 李四这里被执行了 
     * 李四我被回收了 
     * 张三我被回收了 
     */
    //因为$p1引用被重新赋值,最先失去了引用,所以调用了析构函数。
    //然后在这个脚本执行完成后,开始自动调调用后边对象的析构函数,
    //因为$p2,$p3引用存储在栈内,因为栈内后进先出机制,最后创建的对象最先被释放,所以$p3先被销毁。
    

    三、$this
    在对象的内部,在对象的成员方法中访问自己对象的成员属性,或者对象内的其他成员方法,可以用特殊对象应用 t h i s 。 一 旦 我 们 n e w 了 一 个 对 象 , 那 么 对 象 中 的 每 个 成 员 方 法 中 都 存 在 一 个 特 殊 的 对 象 应 用 ‘ this。 一旦我们new了一个对象,那么对象中的每个成员方法中都存在一个特殊的对象应用` thisnewthis。成员方法属于那个对象,那么$this就代表哪个对象。就像你别人要访问你的性别,要用“张三是男生”,但是你自己访问自己的性别,你要用“我是男生”一样。eg3中的例子就用到了$this`。

    四、构造函数和析构函数
    1、构造函数__construct ([ mixed $args [, $... ]] )
    具有构造函数的类会在每次创建新对象时先调用此方法,所以非常适合在使用对象之前做一些初始化工作。
    注意:
    如果子类中定义了构造函数则不会调用其父类的构造函数。
    要执行父类的构造函数,需要在子类的构造函数中调用 parent::__construct()。
    如果子类没有定义构造函数则会如同一个普通的类方法一样从父类继承(假如没有被定义为 private 的话)。

    eg1:

    <?php
    class Base {
       function __construct() {
           print "1";
       }
    }
    
    class Sub extends Base {
       function __construct() {
           parent::__construct();
           print "2";
       }
    }
    
    class OtherSub1 extends Base {
       function __construct() {
           print "2";
       }
    }
    
    class OtherSub2 extends Base {
       
    }
    
    $obj = new Base();//输出1
    $obj = new Sub();//输出12
    $obj = new OtherSub1();//输出2
    $obj = new OtherSub2();//输出1
    

    附:构造函数的参数
    eg:

    <?php
    	class Base {
    		public $name;
    		public function __construct($name = '小王') {
    		   $this->name = $name;
    		}
    		
    		public function name(){
    			echo $this->name;
    		}
    	}
    	$name1 = new Base('小李');
    	$name1->name();//输出‘小李’
    	$name2 = new Base();
    	$name2->name();//输出‘小王’
    

    2、析构函数__destruct ( void )
    析构函数并是不销毁什么,而是会在到某个对象的所有引用都被删除或者当对象被销毁时执行。
    注意
    析构函数没有参数,
    和构造函数一样,父类的析构函数不会被子类中调用,
    要执行父类的析构函数,必须在子类的析构函数体中显式调用 parent::__destruct()。
    此外也和构造函数一样,子类如果自己没有定义析构函数则会继承父类的。
    析构函数即使在使用 exit() 终止脚本运行时也会被调用。在析构函数中调用 exit() 将会中止其余对象的所有引用都被删除或者当对象被销毁的析构函数的执行。这一点,可以通过实例细细体会。

    展开全文
  • 抽象类实例化

    2017-05-25 10:43:08
    抽象类是有构造方法的,但创建...这样创建了继承抽象类子类的对象,也就把其父类(抽象类)给实例化了). 构造方法作用:1.创建对象,2.初始化对象 实例: package day2017_05_25; /** * Created by yaming on

    抽象类是有构造方法的,但创建对象不是通过new来创建的 .而是通过父类的引用来指向子类的实例来间接地实现父类的实例化(因为子类要实例化前,一定会先实例化他的父类。这样创建了继承抽象类的子类的对象,也就把其父类(抽象类)给实例化了).

    构造方法作用:1.创建对象,2.初始化对象

    实例:

    package day2017_05_25;
    
    /**
     * Created by yaming on 17-5-25.
     */
    public abstract class A {
        public A() {
            System.out.println("抽象类A被实例化了");
        }
    }
    
    public class B extends A {
        public B() {
            super();
            System.out.println("子类被实例化了");
        }
    
        public static void main(String[] args) {
            A a=new B();
        }
    }
    
    结果:   抽象类A被实例化了
                 子类被实例化了


    应用(今天用日期类型转换时注意到的):Calendar中的getInstance ( )

    Calendar Cal=  Calendar.getInstance();  

    Calendar是抽象类不能直接通过new对象,但是提供的静态getInstance()就是给Calendar创建对象。
    从Calendar.getInstance() 中所获得的实例其实就是一个 "GreogrianCalendar" 对象

    GreogrianCalendar就是Calendar的子类,他实现了Calendar里面的抽象方法。 过父类的引用来指向子类的实例来间接地实现父类的实例化。同时,使用getInstance()有诸多好处:
    1。 new一定要生成一个新对象,分配内存;getInstance()则不一定要再次创建,它可以把一个已存在的引用给你使用,这在效能上优于new;
    2。new创建后只能当次使用,而getInstance()可以跨栈区域使用,或者远程跨区域使用。所以getInstance()通常是创建static静态实例方法的。



    展开全文
  • 首先我们知道,一个类如果是抽象类,我们就不能用这个类实例化一个对象。什么样的类是抽象类呢? C++没有C Sharp中的关键字abstract,但是当一个类中有一个或多个纯虚函数的时候,这个类就自动成为了抽象类,即不...
  • C#多态性-抽象类对象引用子类实例

    千次阅读 2010-11-22 15:46:00
    C#规定,抽象类不能实例化,如下代码会发生编译错误: Animal myanimal=...首先要明确上面的代码并没有实例化抽象类,只是声明了一个抽象类对象myanimal,实例化时必须通过构造函数来实现,这里调用的是
  • 抽象类可以实例化吗?

    万次阅读 多人点赞 2018-11-01 15:29:45
    抽象类可以有自己的构造方法,但是不能直接通过new进行实例化。但是可以通过子类继承,实例化子类的时候抽象类也会被实例化。这其实用到了多态,向上转型。父类引用指向子类对象~ ...
  • 第8章 抽象类与接口 陶俊 内容大纲 抽象类 修改器与访问器 接口实现 类的多重继承 接口继承 西北大学公共管理学院 陶俊 1 引言 可根据抽象类派生出新的子类再由子类来创建对象 java接口是提升面向对象编程扩展性而...
  • 关于抽象类无法实例化,但是可以使用"new"来实例的疑问. 背景:昨天下午回答一个实习生问的问题,大致的经过是这样的: 他问的:“为什么抽象类无法实例化,但是可以new出来一个实例,官方这么说是什么意思?而且去了各类...
  • 如何实现抽象类实例化

    千次阅读 2018-11-01 12:05:06
    正常情况下抽象类是不能实例化的,但可以模拟实例化,即 利用匿名内部类可以实现抽象类的,举例如下: 1、需要实例化抽象类 代码如下: public abstract class AbstractFruit { private String name; ...
  • java实例化一个抽象类对象

    千次阅读 2019-07-16 16:23:09
    不对啊,根据我的知识一个抽象类不能直接实例化一个对象出来,面向对象期末考试的卷子还有专门一道让你改错的题,一般抽象类直接实例化对象都是每年必考的错误点。那这个对象从哪实例化,国家分配的吗?先不管,结果...
  • 1.父类、子类之间代码块与构造方法public class HelloA { public HelloA(){ System.out.println(&amp;amp;amp;amp;amp;amp;amp;amp;quot;HelloA&amp;amp;amp;amp;amp;amp;amp;amp;quot;); } {System.out....
  • 抽象类是否可以实例化讨论

    千次阅读 2018-04-14 14:59:11
    Answer:(1)、首先,抽象类是不可以实例化的,但只是不可以传统做法中的通过new来进行实例化,而是通过父类的应用来指向子类实例间接地实现父类的实例化,因为子类在实例化之前,一定会优先实例化它的父类。...
  • 今天被问到抽象类要不要有构造函数的时候, 我随口一答应该是没有的, 我以为, 抽象类是不能直接用new来被实例化的, 所以也就不需要再去写构造函数了; 随后查了一下明白: 抽象类也需要构造函数, 在大多数情况中抽象类...
  • 抽象类是由abstract修饰的类,它不能被实例化,但是它也是有构造方法的,只要是类就有构造方法; 抽象类如何变为“实体类”,这里所说的实体类就是可以new出对象的类,我知道只有一种方法,让一个普通类继承这个...
  • java抽象类怎么实例化

    万次阅读 2011-05-08 10:28:00
    Q:程序中A句实例化抽象类OutputStream 怎么回事?抽象类不是不能实例化的么? <br />import java.net.*; import java.io.*; public class TCPClient { public static void main...
  • 抽象类无法直接实例化,它的实例化方式并不是通过普通的new方式来创建对象,而是通过父类的应用来指向子类的实例间接地实现父类的实例化,因为子类实例化之前,一定会先实例化它的父类。这样创建了继承抽象类的...
  • 子类中用override重写父类中用virtual申明的虚方法时,实例化父类调用该方法,执行时调用的是子类中重写的方法;如果子类中用new覆盖父类中用virtual申明的虚方法时,实例化父类调用该方法,执行时调用的是父类中...
  • 关于对java中Class,AbstractClass,Interface的理解 首先关于,我们可以把它当成一个瓶子模具,这里的模具只是用它的概念,不需要带入真正的模具(因为瓶子没有模具),当我们在 java中使用new来新建一个对象...
  • Java的抽象类实例化

    万次阅读 2018-03-19 14:35:37
    简介 《Java编程思想》书中定义...因为抽象类中含有无具体实现的方法,所以一般不能用抽象类创建对象。 // 抽象类 public abstract class ClassName { // 抽象方法:只有声明,而没有具体的实现 abstract voi...
  • Java关于抽象类能否被实例化的问题

    千次阅读 2013-06-25 21:16:14
    我对抽象类能否被实例化产生疑问始于我看到一句话说:子类实例化会先实例化父类。而且,自己也知道,抽象类作为父类,其子类是能调用他的属性和已实现方法的。这证明抽象父类在内存是有一定空间的。(百度百科说:...
  • 子类中用override重写父类中用virtual申明的虚方法时,实例化父类调用该方法,执行时调用的是子类中重写的方法; 如果子类中用new覆盖父类中用virtual申明的虚方法时,实例化父类调用该方法,执行时调用的是父类...
  • 抽象类真的不能实例化么?

    千次阅读 2016-09-25 01:45:24
    原理:抽象类其实是可以实例化的,但是他的实例化方式不是通过new方式来创建对象,而是通过父类的引用来指向子类的实例来间接地实现父类的实例化(因为子类实例化前,一定会先实例化他的父类。这样创建了继承抽象...
  •       接口是我们常用的,抽象类好像并不是怎么常用,但这并不代表他不重要,他可以被继承,可以有构造方法,可以给类中的成员变量赋初值,接口就没有...抽象类不能够被实例化,也就是说
  • 抽象类是不能被实例化的,抽象必须被继承,也就是只能实例化抽象类子类。 但是Java中有一段有趣的功能。 比如: public abstract class MyAbstractclass {} MyAbstractclass是一个抽象类。可以在Main...
  • 类小结2:子类对象和父类对象的转换 final关键字 抽象类
  • abstract 修饰类 (抽象类)不能直接实例化 可以达到 在编译期间提示...抽象类不能直接实例化自己的实例对象 但是可以实例化子类的实例对象 这样就可以在编译期间提示程序员 不要进行一些没有意义的实例操作 ...
  • public class TestClass { private InterfaceA a = new InterfaceA() { @Override public void testA() { ...//成员匿名,例如在Android开发中常用的Handler。 public static void main(St...
  • 在Java中抽象类真的不能实例化么?  在学习的过程中,发现了一个问题,抽象类在没有实现所有的抽象方法前是不可以通过new来构建该对象的,但是抽象方法却是可以有自己的构造方法的。这样就把我搞糊涂了,既然有...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 222,718
精华内容 89,087
关键字:

抽象类子类怎么实例化对象