精华内容
下载资源
问答
  • 继承该接口的 不一定是 一个, 所以要用接口类型去实例化2、在head first 设计模式中 用到了很多很多接口对象首先澄清一个问题,就是接口不仅可以声明对象,而且可以把对象实例化,还可以当做参数被传入。...

    在学接口的时候,看到派生类对象可以实例化接口,想想接口不是不能被实例化的吗?

    一开始想到是多态。

    查阅资料

    发现有以下观点

    1.继承该接口的 类不一定是 一个, 所以要用接口类型去实例化

    2、在head first 设计模式中 用到了很多很多接口对象

    首先澄清一个问题,就是接口不仅可以声明对象,而且可以把对象实例化,还可以当做参数被传入。

    一、接口回调

    这就是继承中的向上转型。父类 FL=new 子类();只不过这里的父类就是interface接口。(个人认为这里不管是class的override还是interface的重写,都是一样的用法)

    可以把实现某一接口类创建的对象的引用赋给该接口声明的接口变量,那么该 
    接口变量就可以调用被类实现的接口中的方法。实际上,当接口变量调用被类实现的接口 
    中的方法时,就是通知相应的对象调用接口方法

    直接上代码

    复制代码
     1 using System;
     2 using System.Collections.Generic;
     3 using System.Linq;
     4 using System.Text;
     5 
     6 namespace ConsoleApplication1
     7 {
     8     interface Itemp
     9     {
    10         double plus();
    11     }
    12     public class num : Itemp
    13     {
    14         double aa, bb;
    15         public num(double a, double b)
    16         {
    17             this.bb = b;
    18             this.aa = a;
    19         }
    20         public double plus()
    21         {
    22             return (aa * bb);
    23         }
    24     }
    25     class Program
    26     {
    27         static void Main(string[] args)
    28         {
    29             num n = null;//声明类对象引用
    30             Itemp tm = null;//声明接口对象引用
    31             tm = new num(1.1, 2.2);//接口回调(向上转型)
    32             Console.WriteLine(tm.plus());
    33             Console.ReadKey();
    34         }
    35     }
    36 }
    复制代码

    通过上面的例子,我们不难看出,接口对象的实例化实际上是一个接口对象作为一个引用 
    ,指向实现了它方法的那个类中的所有方法,这一点非常象C++中的函数指针(在C#中类似委托),但是却是有 
    区别的。C#中的接口对象实例化实际上是一对多的,而C++中的函数指针是一对一的。 
    但是需要注意的是,接口对象的实例化必须用实现它的类来实例化,而不能用接口本身实 
    例化。用接口本身实例化它自己的对象在C#中是不允许的。


    接口可以被实现但是不能创建实例

    展开全文
  • 这个问题我想了一个晚上,看了好几篇别人的博客,但结果都各不相同,每个人有每个人的理解,后来我想明白了:抽象类不能直接通过new去实例化一个对象,那它就是不能实例化,要获取抽象类的对象, 需要先用一个类继承...

    抽象类能实例化吗?

    这个问题我想了一个晚上,看了好几篇别人的博客,但结果都各不相同,每个人有每个人的理解,后来我想明白了:

    抽象类不能直接通过new去实例化一个对象,那它就是不能实例化,要获取抽象类的对象, 需要先用一个类继承抽象类,  然后去实例化子类。也可以用匿名内部类,在抽象类中创建一个匿名的子类,继承抽象类,通过特殊的语法实例化子类的对象 。(后面会细说)

    现在重点来了,要研究这个问题,前提是你要了解抽象类,万变不离其宗,我们从抽象类的根源谈起 , 深化对抽象类的理解。

    首先看这个例子:

    package com.my.animal;//动物类

    public classAnimal {

    String name;//名字

    String color;//颜色

    publicAnimal(String name,String color){this.name =name;this.color =color;

    }public voidrun(){

    System.out.println(name+"四条腿跑的很快!!!");

    }

    }//狗类继承动物类

    classDog extends Animal{publicDog(String name,String color){

    super(name,color);

    }

    }//鱼类继承动物类

    classFish extends Animal{publicFish(String name, String color) {

    super(name, color);

    }

    }classTest{public static voidmain(String[] args) {

    Dog dog= new Dog("哈巴狗","白色");

    dog.run();

    Fish fish= new Fish("锦鲤","红色");

    fish.run();

    }

    }

    运行结果:

    哈巴狗四条腿跑的很快!!!

    锦鲤四条腿跑的很快!!!

    是不是发现问题了,鱼怎么能用腿跑呢,难道是原始鱼?哈哈,开玩笑的,这个问题如何解决,估计大家马上想到了,在子类中重写父类的run方法不就行了,对,确实这样就可以解决,但是大家想过没有,我们是如何发现这个问题的?是不是编译运行之后才看到的,当然,也有大佬能不编译运行就能看到,不抬杠啊,意思是说有发现不了这个问题的风险,对别人可能无所谓,但对我们程序员来说,这种低级错误还是不犯的好,程序员应该有更高的追求,岂能在这被绊倒,我们要把这种风险降为零,那该如何做呢?不急,心急吃不了热豆腐,且看我慢慢分析:

    目前存在的问题:

    1.动物类的run方法描述的不正确

    2.没有强制要子类一定要重写父类的run方法

    解决方案:(抽象类的应用场景)

    我们在描述一类事物的时候,发现该种事物确实存在着某种行为,但是这种行为目前是不具体的,那么我们可以抽取这种行为的声明,但是不去实现该种行为,这时候这种行为我们称作为抽象的行为,我们就需要使用抽象类

    先看下面的例子:

    package com.my.animal;//动物类(抽象类)

    public abstract classAnimal {

    String name;//名字

    String color;//颜色//构造方法

    publicAnimal(String name,String color){this.name =name;this.color =color;

    }

    //非抽象方法

    public void eat(){

    System.out.println(name+"吃东西!!!");

    }//抽象方法

    public abstract voidrun();

    }classDog extends Animal{publicDog(String name,String color){

    super(name,color);

    }

    @Overridepublic voidrun() {

    System.out.println(name+"四条腿跑得快!!");

    }

    }classFish extends Animal{publicFish(String name, String color) {

    super(name, color);

    }

    @Overridepublic voidrun() {

    System.out.println(name+"摇摇尾巴游啊游!!");

    }

    }classTest{public static voidmain(String[] args) {

    Dog dog= new Dog("哈巴狗","白色");

    dog.run();

    Fish fish= new Fish("锦鲤","红色");

    fish.run();

    }

    }

    运行结果:

    哈巴狗四条腿跑得快!!

    锦鲤摇摇尾巴游啊游!!

    这个问题解决了,那还有一个问题就是:抽象类能实例化对象吗?

    看这个例子就知道了:

    public abstract classAnimal {

    String name;

    String color;publicAnimal(String name,String color){this.name =name;this.color =color;

    }public abstract voidrun();

    }classTest{public static voidmain(String[] args) {

    Animal a= newAnimal();

    a.run();

    }

    }

    运行结果:

    Error:(45, 20) java: com.my.animal.Animal是抽象的; 无法实例化

    抽象类注意的细节:

    1.如果一个函数没有方法体,那么该函数必须要使用abstract修饰,把该函数修饰成抽象的函数。

    2.如果一个类出现了抽象的函数,那么该类也必须使用abstract修饰。

    3.如果一个非抽象类继承了抽象类,那么必须要把抽象类的所有抽象方法全部实现。

    4.抽象类可以存在抽象方法,也可以存在非抽象方法,还可以不存在抽象方法,但是这样没任何意义,Java是不写废话的。

    5.抽象类是不能实例化对象的

    6.抽象类是存在构造函数的,其构造函数是提供给子类创建对象的时候初始化父类的属性的。

    疑问:为什么抽象类不能实例化对象?

    因为抽象类是存在抽象方法的,如果能让抽象类创建对象的话,那么使用抽象类的对象调用抽象方法是没有任何意义的。

    疑问排解了,故事结束了?不,学海本无底,我们来点扩展,就是开头提到的如何用匿名内部类去实例化子类对象。

    看下面的例子:

    package Practice_Anything;public abstract classJava_Abstract2 {public voida(){

    System.out.println("我是抽象类中的一个非抽象方法");

    }public staticJava_Abstract2 newIntences(){return newJava_Abstract2(){

    };

    }

    }classTest2{public static voidmain(String[] args) {

    Java_Abstract2 java_abstract2=Java_Abstract2.newIntences();

    java_abstract2.a();

    }

    }

    运行结果:

    我是抽象类中的一个非抽象方法

    这个故事到这就结束了,但是学习还没有停止,比如接口也是一种抽象类型,是抽象方法的集合,由此,我们是不是该联想到学习接口了呢?哈哈,学海本无底,前行莫彷徨!

    此篇为本人原创,花了大概半天时间,找了不知多少相关资料整合而成,如若对你有用,记得推荐,如若哪有不当,感谢指正!

    本文已独家授权给脚本之家(jb51net)公众号独家发布

    展开全文
  • 抽象实例化

    2019-04-03 12:50:00
    抽象类不能直接通过new去实例化一个对象,那它就是不能实例化,要获取抽象类的对象, 需要先用一个类继承抽象类, 然后去实例化子类。也可以用匿名内部类,在抽象类中创建一个匿名的子类,继承抽象类,通过特殊的...

     抽象类能实例化吗?

               这个问题我想了一个晚上,看了好几篇别人的博客,但结果都各不相同,每个人有每个人的理解,后来我想明白了:

             抽象类不能直接通过new去实例化一个对象,那它就是不能实例化,要获取抽象类的对象, 需要先用一个类继承抽象类,  然后去实例化子类。也可以用匿名内部类,在抽象类中创建一个匿名的子类,继承抽象类,通过特殊的语法实例化子类的对象 。(后面会细说)      

     

                现在重点来了,要研究这个问题,前提是你要了解抽象类,万变不离其宗,我们从抽象类的根源谈起 , 深化对抽象类的理解。

     

    首先看这个例子:

         

    package com.my.animal;
    
    //动物类
    public class Animal {
        String name;//名字
        String color;//颜色
    
        public Animal(String name,String color){
            this.name = name;
            this.color = color;
        }
        public void run(){
            System.out.println(name+"四条腿跑的很快!!!");
        }
    }
    //狗类继承动物类
    class Dog extends Animal{
        public Dog(String name,String color){
            super(name,color);
        }
    }
    //鱼类继承动物类
    class Fish extends Animal{
    
        public Fish(String name, String color) {
            super(name, color);
        }
    }
    
    class Test{
        public static void main(String[] args) {
            Dog dog = new Dog("哈巴狗","白色");
            dog.run();
    
            Fish fish = new Fish("锦鲤","红色");
            fish.run();
        }
    }

     

    运行结果:
    
    哈巴狗四条腿跑的很快!!!
    锦鲤四条腿跑的很快!!!
    

      

            是不是发现问题了,鱼怎么能用腿跑呢,难道是原始鱼?哈哈,开玩笑的,这个问题如何解决,估计大家马上想到了,在子类中重写父类的run方法不就行了,对,确实这样就可以解决,但是大家想过没有,我们是如何发现这个问题的?是不是编译运行之后才看到的,当然,也有大佬能不编译运行就能看到,不抬杠啊,意思是说有发现不了这个问题的风险,对别人可能无所谓,但对我们程序员来说,这种低级错误还是不犯的好,程序员应该有更高的追求,岂能在这被绊倒,我们要把这种风险降为零,那该如何做呢?不急,心急吃不了热豆腐,且看我慢慢分析:

           

            目前存在的问题:

                     1.动物类的run方法描述的不正确

                     2.没有强制要子类一定要重写父类的run方法

             解决方案:(抽象类的应用场景)

                      我们在描述一类事物的时候,发现该种事物确实存在着某种行为,但是这种行为目前是不具体的,那么我们可以抽取这种行为的声明,但是不去实现该种行为,这时候这种行为我们称作为抽象的行为,我们就需要使用抽象类

             先看下面的例子: 

     

    package com.my.animal;
    //动物类(抽象类)
    public abstract class Animal {
        String name;//名字
        String color;//颜色
           //构造方法
        public Animal(String name,String color){
            this.name = name;
            this.color = color;
        }
    //非抽象方法
    public void eat(){
    System.out.println(name+"吃东西!!!");
    }
    //抽象方法 public abstract void run(); } class Dog extends Animal{ public Dog(String name,String color){ super(name,color); } @Override public void run() { System.out.println(name+"四条腿跑得快!!"); } } class Fish extends Animal{ public Fish(String name, String color) { super(name, color); } @Override public void run() { System.out.println(name+"摇摇尾巴游啊游!!"); } } class Test{ public static void main(String[] args) { Dog dog = new Dog("哈巴狗","白色"); dog.run(); Fish fish = new Fish("锦鲤","红色"); fish.run(); } }

     

     

    运行结果:
    
    哈巴狗四条腿跑得快!!
    锦鲤摇摇尾巴游啊游!!
    

      

    这个问题解决了,那还有一个问题就是:抽象类能实例化对象吗?

    看这个例子就知道了:

         

    public abstract class Animal {
        String name;
        String color;
    
        public Animal(String name,String color){
            this.name = name;
            this.color = color;
        }
        public abstract void run();
    }
    
    class Test{
        public static void main(String[] args) {
            Animal a = new Animal();
            a.run();
        }
    }

     

     

    运行结果:
    
    Error:(45, 20) java: com.my.animal.Animal是抽象的; 无法实例化
    

      

     

     

    抽象类注意的细节:

             1.如果一个函数没有方法体,那么该函数必须要使用abstract修饰,把该函数修饰成抽象的函数。

             2.如果一个类出现了抽象的函数,那么该类也必须使用abstract修饰。

             3.如果一个非抽象类继承了抽象类,那么必须要把抽象类的所有抽象方法全部实现。

             4.抽象类可以存在抽象方法,也可以存在非抽象方法,还可以不存在抽象方法,但是这样没任何意义,Java是不写废话的。

             5.抽象类是不能实例化对象的

             6.抽象类是存在构造函数的,其构造函数是提供给子类创建对象的时候初始化父类的属性的。

                

              

     疑问:为什么抽象类不能实例化对象?

                因为抽象类是存在抽象方法的,如果能让抽象类创建对象的话,那么使用抽象类的对象调用抽象方法是没有任何意义的。

               

    疑问排解了,故事结束了?不,学海本无底,我们来点扩展,就是开头提到的如何用匿名内部类去实例化子类对象。

    看下面的例子:

     

    package Practice_Anything;
    
    public abstract class Java_Abstract2 {
    
        public void a(){
            System.out.println("我是抽象类中的一个非抽象方法");
        }
    
        public static Java_Abstract2 newIntences(){
            return new Java_Abstract2(){
    
            };
        }
    }
    
    class Test2{
        public static void main(String[] args) {
            Java_Abstract2 java_abstract2 = Java_Abstract2.newIntences();
            java_abstract2.a();
        }
    }

     

     

    运行结果:
    
    我是抽象类中的一个非抽象方法
    

      

     

    这个故事到这就结束了,但是学习还没有停止,比如接口也是一种抽象类型,是抽象方法的集合,由此,我们是不是该联想到学习接口了呢?哈哈,学海本无底,前行莫彷徨!

     

    此篇为本人原创,花了大概半天时间,找了不知多少相关资料整合而成,如若对你有用,记得推荐,如若哪有不当,感谢指正!

      本文已独家授权给脚本之家(jb51net)公众号独家发布

    展开全文
  • java对象实例化过程分析

    千次阅读 2016-02-29 00:23:17
    一个对象可以使用之前,需要经过加载和实例化,也就是我们今天的主题“new一个java对象的过程”。那虚拟机在什么时机进行加载呢?Java 虚拟机规范并没有对其做严格的定义,不同的JVM有不同的实现。而初始化的...

    我们平时经常随手就new一个对象出来,但是找对象真的这么简单吗?看看下面的分析~
    首先看一下类的生命周期
    这里写图片描述
    图中从2到4的过程统称为连接,而1-5这5个过程合起来称为类加载。在一个对象可以使用之前,需要经过类加载和实例化,也就是我们今天的主题“new一个java对象的过程”。

    那虚拟机在什么时机进行类加载呢?Java 虚拟机规范并没有对其做严格的定义,不同的JVM有不同的实现。而初始化的时机JVM明确规定为”initialize on first active use”–” 在首次主动使用时初始化”。
    “主动使用”的定义:

    • 创建某个类的新实例时–new、反射、克隆或反序列化;
    • 调用某个类的静态方法时;
    • 使用某个类或接口的静态字段或对该字段赋值时(final字段除外);
    • 调用Java的某些反射方法时
    • 初始化某个类的子类时
    • 在虚拟机启动时某个含有main()方法的那个启动类。

    下面说明类加载各个过程进行的操作:
    (1)装载:使用类加载器对class文件进行加载。

    1. 通过类全限定名来获取二进制字节流
    2. 将静态存储结构调到方法区
    3. 在java堆上生成这个类的class对象,作为方法区数据入口

    (2)验证:

    1. 文件格式验证
    2. 元数据验证
    3. 字节码验证
    4. 符号引用验证

    (3)准备:为类变量(也就是静态变量)分配内存,设置初始值(这里的初始值是规定的,比如一般对象的初始值为null,int类型为0,boolean类型为false,等等)

    (4)解析:将常量池的符号引用替换为直接引用。

    (5)初始化:为类变量赋初始值,执行static语句。这里JVM会将这些语句全部放到<clinit>()方法中执行,并且<clinit>()方法是线程安全的。

    (6)实例化:为新建对象分配内存,初始化实例变量,执行构造函数。JVM会将实例变量,构造语句等非静态语句按顺序添加到每一个构造方法里面。所以语句的执行顺序是先按顺序执行类中的非静态语句,再执行构造方法中的语句。

    这就是我们平时new一个对象时jvm所进行的操作了,是不是还挺麻烦的,不过这里只是大致的分析了一下,主要参考了《深入理解java虚拟机》这本书,但是并没有深入的分析,想要详细了解到字节码的程度,还是推荐直接看书吧。

    展开全文
  • 接口不能实例化,用接口的实现可以实例化,将实现对象在内存中的地址指向接口,这接口就可以使用了 二、 实现接口的 实例 = new 实现接口的()// 这样用不好吗? //这样已经不是好不好的问题了,...
  • 抽象类不能直接通过new去实例化一个对象,那它就是不能实例化,要获取抽象类的对象, 需要先用一个类继承抽象类, 然后去实例化子类。也可以用匿名内部类,在抽象类中创建一个匿名的子类,继承抽象类,通过特殊的...
  • 抽象实例化问题

    2019-09-24 11:34:47
    抽象类能实例化吗? ... 这个问题我想了一个晚上,看了好几篇别人的博客,但结果都各不相同,每个人有... 抽象类不能直接通过new去实例化一个对象,那它就是不能实例化,要获取抽象类的对象, 需要先用一个类继承抽象...
  • 面向对象第一次听到这个词字面意思...,今天吃两个菜 名吃一个菜 可以后天吃三个 面向过程就只能做完这个菜以后才能做第二个 面向对象可以直接或间接性做三个菜或者更多,让我们进入代码中来了解真正的面向对象吧那...
  • Class2 c2=new Class2();...这里的c3只是一个引用,在内存中指向同一个对象,因此,c2,c3其实是同一个对象,我希望有一个操作,能够帮我复制一个实例的状态,也就是内存中有两片区域,肯请指点 ...
  • 、接口不能实例化,用接口的实现可以实例化,将实现对象在内存中的地址指向接口,这接口就可以使用了 二、 实现接口的 实例 = new 实现接口的()// 这样用不好吗? //这样已经不是好不好的问题了,...
  • 如何保证一个类只有一个实例化对象,这不就是单例吗,经常用的额 这两个不都是一样的吗,怪自己太年轻,不懂 变通啊。。。   回头一搜,这篇文章介绍的更详细一些,里面介绍了如何在堆上或者栈上 ...
  •   另外,子类继承抽象类的时候,重写了所有抽象方法,并实例化一个子类对象的时候,会实例化父类,也就是抽象类吗?不可能呀,抽象类是不能实例化的。   所以创建子类实例的时候不会创建父类实例。 ...
  • 提个问题:如果当创建一个子类对象会先创建父类对象的话,那么如果父类是抽象的话,那该抽象父类也会被实例化喽,这与抽象不能实例化相互矛盾啊! ![图片说明]...
  • // 创建一个书的对象,不是new实例化的,而是通过方法从图书馆借来的 Book book = Book.libraryBorrow(); } } 这里的 static public Book libraryBorrow()显然认为返回值类型是Book类型 ,我标题的理解对...
  • 抽象实例化 01 是 C++ 的核心特性,通常被称为用户定义的类型。也就是说,它和其他基本类型一样(浅显的这么说),都是type。定义是以关键字 class 开头,后跟的名称。由可以生成对象,这里,对象...
  • 【Java】——对象

    2020-12-25 18:49:35
    类和对象 1.要想了解类和对象,首先在此提出 “面向对象”的概念: 面向对象是思考问题的一种方式吗...——一个类主要包含一个事物的属性和行为。 2.类和类的实例化: 1.)类就是一对象的统称,对象就是这一类具体
  • 零碎知识点杂乱,所以...(1)抽象不能实例化 (2)抽象方法是必须被子重写的方法 (3)如果中包含抽象方法,那么就必须定义为抽象 【什么时候用】 当设计一个新的抽象时,一定是用来继承的。在一个
  • 我现在是用QT写了一个Modbustcpclient,然后client对象中首先实例化了client后,新建线程并将其加入。 仅复制了部分关键代码。 MainWindow中 client1 = new Client(0, newClientConfig); 在Client中 ``` ...
  • 上次使用中我也把连接对象 DatagramSocket 写成了静态的,在类的初始时使用,可是系统中有很多地方使用,难道我要不断的创建这个类对象吗?可以这么做,当时有后果,后果就是内存溢出。UDP是没有状态的,...
  • C#基础知识-对象

    2014-01-09 17:12:23
    的定义:具有相同属性和功能的对象的抽象的集合。——脑门闪,其实也是集合吗? 的实例:实例化就是创建对象的过程,使用new关键字来创建。 来看以下代码,最简单的,你肯定懂:
  • python一切皆对象,所有内容都是由对象展开的,对象是由类实例化而来。python中存储的所有数据都是对象。每个对象都有一个身份、一个类型和一个值。身份:eg:school=“beida” 会以 “beida”创建一个字符串对象,...
  • 面向对象是把整个需求按照特点、功能划分,将这些存在共性的部分封装成类实例化后才是对象),创建了对象不是为了完成某一个步骤,而是描述某个事物在解决问题的步骤中的行为 1.1.1 能举个例子谈谈你对面向过程...
  • 在上篇博文里,传入参数时,是在实例化对象后且在调用方法时才传入参数,感觉是不是有点繁琐对吧?可以在实例化的时候就传入参数吗?可以的,这就是本篇博文的要讲到的构造器——__init__(两边双下划线)__init__...
  • 1、名词解释代表了具有相同特征的一事物(人)对象、实例:具体的某一个事物或者是人实例化:将变成对象的这么一个过程,即新建一个对象的过程,就是一个实例化过程。2、格式函数定义:def func1():...
  • 单例模式,保证一个类仅有一个实例,并提供一个访问它的全局访问点。通常我们可以让一个全局变量使得一个对象被访问,但它不能防止你实例化多个对象。一个好的方法就是,让类自身负责保存它的唯一实例。这个类可以...
  • 一、接口类(面向对象开发的思想和规范)的多...其他两个tiger类和hawk类则不能满足(b)而以下代码确切定义每一个类,每个类的属性都都在类里面存在,这样写虽然可以满足前面的需求,但是不好的地方就是,重复的方法...
  • -- 扫描Mapper中的抽象 ,实例化之后会自动装配--> <!-- (事务管理)transaction manager, use JtaTransactionManager for global tx --> class="org.springframework.jdbc.datasource....
  • 答案是:不必须。 这个题目主要是考察对抽象类的理解。 ...4.最关键的一点就是如果一个类是抽象类,那么这个类是不能被实例化的。 抽象类只能用其子类(该子类不能是抽象类)去创建新对象。 ...
  • 1. 接口接口提取了一群共同的函数,可以把接口当做一个函数的集合。...# java : 面向对象编程# 设计模式 —— 接口# 接口 : python原生不支持# 接口不可以实例化from abc import abstractmethod,ABCM...
  • 一、接口类(面向对象开发的思想和规范)的多...其他两个tiger类和hawk类则不能满足(b)而以下代码确切定义每一个类,每个类的属性都都在类里面存在,这样写虽然可以满足前面的需求,但是不好的地方就是,重复的方法...

空空如也

空空如也

1 2 3 4 5 ... 10
收藏数 198
精华内容 79
关键字:

对象实例化就是一个类吗