精华内容
下载资源
问答
  • 创建抽象类匿名子类对象 父类 抽象类——Person abstract class Person { //其他方法及变量定义 ..... //抽象方法 public abstract void eat(); } 创建Person类的匿名子类对象 //method 为已创建的一...

    创建抽象类的匿名子类对象

    父类 抽象类——Person

    	abstract class Person {
    		//其他方法及变量定义
    		.....
    		//抽象方法
    		public abstract void  eat();
    	}
    
    

    创建Person类的匿名子类对象

    //method 为已创建的一个方法
    		method(new Student)//非匿名类的匿名对象
    	
    		Student stu  = new Student();
    		method(stu);//非匿名的类的非匿名对象
    
    
    //创建了一匿名类的对象,对象名为p
    		Person p = new Person{
    			//覆盖(实现)父类Person中的抽象方法
    			@Override
    			public void eat(){
    			//方法体
    			}
    		}
    //调用匿名子类对象
    		method(p);
    

    使用目的:只会使用一次的类,就不用新建一个类。最终目标——省事

    创建Person类的匿名子类的匿名对象

    		method(new Person{
    		//覆盖Person类中的抽象类方法
    		@Override
    		public void  eat(){
    		//具体实现的方法体
    		
    		}
    		})
    
    展开全文
  • Java抽象类匿名子类

    2021-08-11 10:57:00
    抽象类匿名子类 涉及到匿名的东西,都是只用一次,目的就是为了省事!(有时候不一定用,但是为了看得懂代码,这个还是要有所了解的) 1.非匿名类的匿名对象 2.匿名类的非匿名对象 3.匿名子类的非匿名对象 4.匿名...

    抽象类的匿名子类

    涉及到匿名的东西,都是只用一次,目的就是为了省事!(有时候不一定用,但是为了看得懂代码,这个还是要有所了解的)

    1.非匿名类的匿名对象
    2.非匿名类的非匿名对象
    3.匿名子类的非匿名对象
    4.匿名子类的匿名对象

    匿名说到底就分为以上四种情况,下面将从程序中弄清楚这四种情况的用法:

    package com.java.oop5;
    
    /**
     * @description: 抽象类的匿名子类
     * 涉及到匿名的东西,都是只用一次,目的就是为了省事!
     * 1.非匿名类的匿名对象
     * 2.非匿名类的非匿名对象
     * 3.匿名子类的非匿名对象
     * 4.匿名子类的匿名对象
     * @author: Fish_Vast
     * @Date: 2021/8/11
     * @version: 1.0
     */
    public class PersonTest {
        public static void main(String[] args) {
            show1(new Worker());    //1.非匿名类Worker的匿名对象
            System.out.println("******************");
            Worker w = new Worker();
            show1(w);               //2.非匿名类的非匿名对象w
            System.out.println("******************");
            Person p = new Person() {   //3.匿名子类的非匿名对象p
                @Override
                public void run() {
                    System.out.println("跑步跑步");
                }
    
                @Override
                public void breath() {
                    System.out.println("呼吸呼吸");
                }
            };  //注意这里是要加分号的!!!
            /*因为在抽象方法中不能进行对象的实例化,不能造对象,但是我们假设暂时不知道子类的名字是什么,
            *所以借助子类重写方法来实现方法的调用。
            */
            show1(p);
            System.out.println("******************");
            //这里是干脆就连对象名也省去,得从上至下慢慢梳理一遍就能懂其思想了。
            show1(new Person(){ //4.匿名子类的匿名对象(最省事!!!)
                @Override
                public void run() {
                    System.out.println("跑步");
                }
                @Override
                public void breath() {
                    System.out.println("呼吸");
                }
            });
        }
    
        public static void show1(Person p){
            p.breath();
            p.run();
        }
    }
    
    class Worker extends Person{
        @Override
        public void run() {
            System.out.println("好好运动");
        }
    
        @Override
        public void breath() {
            System.out.println("多呼吸新鲜空气");
        }
    }
    
    package com.java.oop5;
    
    /**
     * @description:
     * @author: Fish_Vast
     * @Date: 2021/8/11
     * @version: 1.0
     */
    public abstract class Person {
        public Person() {
    
        }
        public abstract void run();
        public abstract void breath();
    }
    

    在这里插入图片描述

    展开全文
  • 这里的Person类是抽象类类,抽象类本身是不能被实例化的。 package oopabstract; public class AbstractClassAnonymous { public static void main(String[] args) { Worker worker = new Worker(); method...

    这里的Person类是抽象类类,抽象类本身是不能被实例化的。

    package oopabstract;
    
    public class AbstractClassAnonymous {
        public static void main(String[] args) {
            Worker worker = new Worker();
            method(worker);//非匿名类的非匿名对象
    
            System.out.println("=======================");
    
            Person p = new Person() {//抽象类本身是不能造对象的
                @Override
                public void eat() {
                    System.out.println("抽象类的匿名子类的非匿名对象 + eat方法");
                }
    
                @Override
                public void breathe() {
                    System.out.println("抽象类的匿名子类的非匿名对象 + breathe方法");
                }
            };
            method(p);//抽象类的匿名子类的非匿名对象
    
            System.out.println("=======================");
    
            method(new Person() {///抽象类本身是不能造对象的
                @Override
                public void eat() {
                    System.out.println("抽象类的匿名子类的匿名对象 + eat方法");
                }
    
                @Override
                public void breathe() {
                    System.out.println("抽象类的匿名子类的匿名对象 + breathe方法");
                }
            });
        }
    
        public static void method(Person p) {
            p.eat();
            p.breathe();
        }
    }
    
    
    
    abstract class Person {
        private String name;
        private int age;
        public Person() {
        }
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
        public abstract void eat();
        public abstract void breathe();
    }
    
    
    class Worker extends Person {
        @Override
        public void eat() {
            System.out.println("Worker的eat方法");
        }
        @Override
        public void breathe() {
            System.out.println("Worker的breathe方法");
        }
    }
    
    
    展开全文
  • 匿名对象我们经常会用到,但是类呢? 类还能匿名? 类匿名了还能创建对象,并且能创建有名对象和匿名对象

     

    匿名对象我们经常会用到,但是类呢? 类还能匿名?

    类匿名了还能创建对象,并且能创建有名对象和匿名对象。

    开发中很少用到,但是在源码中经常会看到以上情形...

    现在给定一个抽象类Order

    abstract class Order{
        	public abstract void show();
    }

    因为Order是抽象的,我们无法通过 Order o = new Order(); 创建Order类的对象 : Cannot instantiate the type Order

    我们将该语句添加点内容:

    Order o = new Order(){ };  {} 中 提供 抽象类 Order 需要重写的方法

    Order o = new Order(){
    			@Override
    			public void show() {
    				System.out.println("this is book order.");
    			}
    		};
    		System.out.println(o.getClass());
    		System.out.println(o.getClass().getSuperclass());

    结果输出为 

    class com.ylaihui.oop11.OrderTest$1
    class com.ylaihui.oop11.Order

     分析:对象o的父类是Order,但是没有提供实例化该对象的类的名称,也就是实例化该对象的类是匿名的,但是该对象是有名的,所以现在演示的是抽象类的匿名子类的有名对象

     

    假设有以下方法

    public static void method(Order o){
    		o.show();
    	}

    我们这样调用该方法

    method(o);
    很明显这是多态的形式, 形参是 Order类型,实参是 Order类的子类对象, Order类的子类是匿名的,对象名是 o

    假如我们想给method方法传一个匿名对象, 

    method(new Order()); 但是这样会报错,Cannot instantiate the type Order

    根据上面的写法我们这样补充代码:{} 中提供需要重写的方法

    		method(new Order(){
    			@Override
    			public void show() {
    				System.out.println("this is computer order.");
    			}
    		});

    分析:

    创建匿名子类的匿名对象,类是没名字的,对象也是没名字的。

     

    以上开发中是少见的,但是在Java的源码中经常会看到这样的用法,见到了这样的源码,能看懂就够了...

    实例代码 OrderTest.java

    //OrderTest.java
    package com.ylaihui.oop11;
    
    abstract class Order{
        	public abstract void show();
    }
    
    public class OrderTest {
    	
    	public static void method(Order o){
    		o.show();
    	}
    	public static void main(String[] args) {
    		
    		// Cannot instantiate the type Order
    //		Order o = new Order();
    		
    		// Order o = new Order(){};  -- {} 中 提供 抽象类 Order 需要重写的方法
    		//创建了一匿名子类的对象:p
    		Order o = new Order(){
    			@Override
    			public void show() {
    				System.out.println("this is book order.");
    			}
    		};
            System.out.println(o.getClass());
            System.out.println(o.getClass().getSuperclass());
    		
    		// 多态, 形参是 Order类型,实参是 Order类的子类对象, Order类的子类是匿名的,对象名是 o
    		method(o);
    		//-----------------------------------------
    		//创建匿名子类的匿名对象
    		//method(new Order());  // Cannot instantiate the type Order
    		//method(new Order(){}); // {} 中提供需要重写的方法  
    		method(new Order(){
    			@Override
    			public void show() {
    				System.out.println("this is computer order.");
    			}
    		});
    	}
    }

    代码输出

    class com.ylaihui.oop11.OrderTest$1
    class com.ylaihui.oop11.Order
    this is book order.
    this is computer order.

    关键代码: 

     

    展开全文
  • /* * 抽象类匿名子类 * */ public class PersonTest { public static void main(String[] args) { method(new Student());//匿名对象 Worker worker = new Worker(); method1(worker);//非匿名的...
  • 抽象类匿名子类

    2021-05-12 22:56:56
    抽象类匿名子类 abstract class PersonOfInterest { private String name; private String guyKind; public PersonOfInterest(String name, String guyKind) { super(); this.name = name; this....
  • Java基础语法67-创建抽象类匿名子类对象 package com.java9; /* * 抽象类的匿名子类 * */ public class PersonTest { public static void main(String[] args) { method(new Student());//匿名对象 ...
  • 如何写抽象类匿名子类

    千次阅读 2021-05-11 20:26:50
    在创建匿名子类对象的时候重写抽象类中的方法 抽象类 package java; public class AbstractTest { public static void main(String[] args) { Student stu = new Student();//创建Student类的对象stu ...
  • * **抽象类匿名子类和匿名对象** * * * */ public class PeronTest { public static void main(String[] args) { method(new Student()); //匿名对象 worker worker = new worker(); ...
  • 开发中,都会提供抽象类的子类,让子类对象实例化,完成相关的操作 4.abstract修饰方法:抽象方法 抽象方法只有方法的声明,没有方法体 包含抽象方法的类,一定是一个抽象类。反之,抽象类中是可以没有抽象方法的...
  • 抽象类和抽象方法的使用 抽象类和抽象方法的使用 ... /* * abstract关键字的使用 * 1.abstract:抽象的 * 2.abstract可以用来修饰的结构:类、方法 ... 开发中,都会提供抽象类的子类,让子类对象
  • 匿名对象 匿名就是没有名字的对象,在创建对象时,只通过new的动作在堆内存开辟空间,却没有把堆内存空间的地址值赋值给栈内存的某个变量用以存储 class Student{ String name; public Student(){ this.name = ...
  • JAVA——抽象类

    千次阅读 2021-03-09 00:47:50
    一、抽象类的概念包含一个抽象方法的类就是抽象类,其本质是对多个普通类中相同的部分的抽象。二、抽象类的特点1.抽象方法和抽象类使用 abstract 修饰;...6.抽象类的抽象方法强制子类重写;7. 抽象类中所有的内容...
  • 继承的特性是单一继承,接口可以实现多个继承,接口里的所有方法全是抽象方法,接口和的关系是实现,implements 格式: interface 接口名{ } 接口成员特点 接口中只能有抽象方法,只能有常量 默认且只能使用 public&...
  • 抽象类与抽象方法 随着继承层次中一个个新子类的定义,类变得越来越具体,而父类则更一般,更...》 抽象类中一定有构造器,便于子类实例化时调用(涉及:子类对象实例化全过程)(只要类就要构造器) 》 开发中,都会提供
  • 当我创建抽象类对象时,我必须这样做,就像一个接口一样。AbstractClass abstractClass = new AbstractClass() {@Overridepublic void abstractMethod() {}};这是否意味着AbstractClass的对象是一个匿名的内部类...
  • 开发中,都会提供抽象类的子类,让子类对象实例化,完成相关的操作 abstract修饰方法:抽象方法 > 抽象方法只有方法的声明,没有方法体 > 包含抽象方法的类,一定是一个抽象类。反之,抽象类中可以没有抽象...
  • 抽象匿名子类

    2021-11-27 12:30:26
    * 抽象匿名子类 */ public class PersonTest { public static void main(String[] args) { // TODO Auto-generated method stub method(new Student("xt",23)); //匿名对象 Worker w=new Worker(); ...
  • Java抽象类匿名对象

    2021-12-07 22:46:07
    抽象类匿名子类 */ public class AbstractTest1 { public static void main(String[] args) { method(new Student());//匿名对象 Woker woker=new Woker(); method1(woker);//非匿名的类非匿名的对象 ...
  • 前言首先声明,用接口或者抽象类实例化一个对象是不可能的,错误的。接口、抽象类实现注意点Interface属性默认都是 public static final方法默认都是 public abstract都不用显示声明抽象类至少含有一个方法是...
  • 匿名对象 没有变量名的对象 特点 匿名对象如果不给变量赋值 只能使用一次 匿名对象可以作为方法的参数和返回值 常见的使用:为ArrayList添加对象 ArrayList<Person> list = new ArrayList<Person>()...
  • 是对现实生活中一具有共同属性和行为的事物的抽象对象的数据类型。 属性:对象有什么特征 方法:对象能干什么 垃圾回收: 在堆内存中的对象或数组,其地址通过任何方式都不能被找到,就会被判定为...
  • 抽象类能实例化吗

    2021-02-12 14:14:53
    抽象类能实例化吗?这个问题我想了一个晚上,看了好几篇...也可以用匿名内部类,在抽象类中创建一个匿名子类,继承抽象类,通过特殊的语法实例化子类的对象 。(后面会细说)现在重点来了,要研究这个问题,前提是你...
  • Java 面向对象(下 2)

    2021-07-05 22:57:22
    * 2.Java中,接口和是并列的两个结构 * 3.如何定义接口:定义接口中的成员 * * 3.1 JDK7及以前:只能定义全局常量和抽象方法 * >全局常量:public static final的.但是书写时,可以省略不写 * >抽象方法:...
  • 1.多态 多态的理解 (1)同一个动作作用于不同的对象产生的不同的行为,比如不同子类...(4)子类对象的多态性:父类的引用指向子类的实例。 程序分为两种状态,一种是编译时状态,一种是运行时状态。 举例:Pet p1 =
  • 1.情景展示如上图所示,每个服务层都需要注入这个工具类对象2.原因分析如果我们每个实现类都加上这样一行代码,实属麻烦...这里需要说明的有两点:第一,抽象类也可以使用spring注解完成对象的注入;第二,通常我们...
  • 文章目录对java中main方法的解释代码块final关键字抽象类与抽象方法abstract关键字可以用来修饰类、方法抽象类匿名子类对象的写法模板方法设计模式 对java中main方法的解释 public static void main(String[] args...
  • 创建抽象类匿名对象 public class PersonTest { public static void main(String[] args) { method(new Student());//称为匿名对象 没有给对象赋值 Worker worker = new Worker(); method1(worker);//非匿名...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 47,391
精华内容 18,956
关键字:

抽象类的匿名子类对象