精华内容
下载资源
问答
  • 抽象类匿名子类

    2021-01-31 18:17:43
    抽象类匿名子类 在B站学习java写的代码 代码如下 PersonTest类 package com.day0130_2; /* * 抽象类匿名子类 * */ public class PersonTest { public static void main(String[] args) { method(new ...

    抽象类的匿名子类

    在B站学习java写的代码
    代码如下

    PersonTest类

    package com.day0130_2;
    /*
     * 抽象类的匿名子类
     * 
     */
    public class PersonTest {
    
    	public static void main(String[] args) {
    		
    		method(new Student());//匿名对象
    		
    		Worker worker =new Worker();
    		method1(worker);//非匿名的类 非匿名的对象
    		
    		method1(new Worker());//非匿名的类 匿名的对象
    		
    		System.out.println("*****************");
    		
    		//创建了一匿名子类的对象:p
    		Person p=new Person() /*多态*/{
    
    			@Override
    			public void eat() {
    				System.out.println("吃东西");
    			}
    			
    			@Override
    			public void breath() {
    				System.out.println("好好呼吸");
    			}
    			
    		};
    		
    		method1(p);
    		/*
    		吃东西
    		好好呼吸
    		*/
    		
    		System.out.println("*****************");
    		//创建匿名子类的匿名对象
    		method1(new Person () {
    			
    			@Override
    			public void eat() {
    				System.out.println("吃好吃的东西");
    			}
    			
    			@Override
    			public void breath() {
    				System.out.println("好好呼吸新鲜空气");
    			}
    			
    		});
    		
    	}
    	
    	public static void method1(Person p) {//多态
    		p.eat();
    		p.breath();
    	}
    	
    	public static void method(Student s) {
    		
    
    	}
    }
    
    abstract class Creature{
    	
    	public abstract void breath();
    	
    	
    	
    }
    
    abstract class Person extends Creature{
    	
    	String name;
    	int age;
    	
    	public Person() {
    		
    	}
    	
    	public Person(String name,int age) {
    		this.name=name;
    		this.age=age;
    	}
    	
    	//抽象方法
    	public abstract void eat();
    	
    	public void walk() {
    		System.out.println("人走路");
    	}
    	
    	
    }
    
    class Worker extends Person{
    	
    	@Override
    	public void eat() {
    	}
    
    	@Override
    	public void breath() {
    	}
    	
    	
    }
    
    展开全文
  • 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();
    }
    

    在这里插入图片描述

    展开全文
  • 匿名对象我们经常会用到,但是类呢? 类还能匿名? 类匿名了还能创建对象,并且能创建有名对象和匿名对象。

     

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

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

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

    现在给定一个抽象类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.

    关键代码: 

     

    展开全文
  • 创建抽象类匿名子类对象 父类 抽象类——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(){
    		//具体实现的方法体
    		
    		}
    		})
    
    展开全文
  • 抽象类匿名子类的写法: 在创建匿名子类对象的时候重写抽象类中的方法 抽象类Person public abstract class Person { public abstract void eat(); public abstract void walk(); } 如何写抽象类匿名子类...
  • Java基础语法67-创建抽象类匿名子类对象 package com.java9; /* * 抽象类匿名子类 * */ public class PersonTest { public static void main(String[] args) { method(new Student());//匿名对象 ...
  • 开发中,都会提供抽象类子类,让子类对象实例化,完成相关的操作 abstract修饰方法:抽象方法 > 抽象方法只有方法的声明,没有方法体 > 包含抽象方法的类,一定是一个抽象类。反之,抽象类中可以没有抽象...
  • java中抽象类匿名子类对象 package com.atguigu.java; /* * 抽象类匿名子类 * */ public class PersonTest { public static void main(String[] args) { method(new Student());//匿名对象 ...
  • * **抽象类匿名子类和匿名对象** * * * */ public class PeronTest { public static void main(String[] args) { method(new Student()); //匿名对象 worker worker = new worker(); ...
  • 这里的Person类是抽象类类,抽象类本身是不能被实例化的。 package oopabstract; public class AbstractClassAnonymous { public static void main(String[] args) { Worker worker = new Worker(); method...
  • 抽象类及抽象方法 abstract修饰类:抽象类。此类不能实例化,即不能...子类继承抽象类中的方法,要想让子类实例化,则可通过 ① 重写抽象类中方法;② 将该类变为抽象类。 总结: ① abstract不能用来修饰:属性.
  • 匿名对象: 1 method(new Student())匿名对象 2 Worker worker = new ...4//创建了一你匿名子类的对象p,这里new的Person不是person而是person代表的子类 Person p = new Person(){ 这里是重写的方法 } ...
  • 抽象类匿名子类 Person p1 = new Person(){ //创建了一个匿名类的对象 @Override public void haha() { } };
  • public static void main(String[] args){ method(new Student());//匿名对象 Worker worker=new Worker(); method1(worker);//非匿名的类非匿名的对象 method1(new Worker());//非匿名的类匿名的对象 ...
  • 抽象类和抽象方法的使用 抽象类和抽象方法的使用 ... /* * abstract关键字的使用 * 1.abstract:抽象的 * 2.abstract可以用来修饰的结构:类、方法 ... 开发中,都会提供抽象类子类,让子类对象实
  • 抽象类匿名子类 代码: package test3; public class PersonTest { public static void main(String[] args) { method(new Student());// 匿名对象 Worker worker = new Worker(); method1(worker);// 非...
  • /* * 抽象类匿名子类 * */ public class PersonTest { public static void main(String[] args) { method(new Student());//匿名对象 Worker worker = new Worker(); method1(worker);//非匿名的...
  • 1、 非静态方法----》创建对象来调用 ...3、创建一匿名子类对象(这里Person当做匿名子类对象,不是超类抽象类) Person p = new Person(){ public eat(){ ...} public walk(){...} //重写里面的方法 } ...
  • 扩展scala 扩展的方式和Java一样, 使用 extends 关键字,例如:class Person(val Name:String){ def show() = {println("person name: " + Name)} }class Student(name:String) extends Person(name){ private...
  • /** * @Author: YuShiwen * @Date: 2020/11/18 2:06 PM * @Version: 1.0 ... //非匿名类 的 非匿名对象,即名为Freshman,对象名为:freshman Freshman freshman = new Freshman("Mr.Yu",18);

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 46,297
精华内容 18,518
关键字:

抽象类的匿名子类