精华内容
下载资源
问答
  • 抽象类的实现问题

    千次阅读 2018-12-14 09:05:22
    抽象类的实现问题 包含抽象方法的类称为抽象类,但并不意味着抽象类中只能有抽象方法,它和普通类一样,同样可以拥有成员变量和普通的成员方法。注意,抽象类和普通类的主要有三点区别: 1)抽象方法必须为public...

    抽象类的实现问题

    包含抽象方法的类称为抽象类,但并不意味着抽象类中只能有抽象方法,它和普通类一样,同样可以拥有成员变量和普通的成员方法。注意,抽象类和普通类的主要有三点区别:

    1)抽象方法必须为public或者protected(因为如果为private,则不能被子类继承,子类便无法实现该方法),缺省情况下默认为public。

    2)抽象类不能用来创建对象;

    3)如果一个类继承于一个抽象类,则子类必须实现父类的抽象方法。如果子类没有实现父类的抽象方法,则必须将子类也定义为为abstract类。

    在其他方面,抽象类和普通的类并没有区别。

    例如:
    abstract class Animal{
    abstract void say();
    }
    public class Cat extends Animal{
    public Cat(){
    System.out.printf(“I am a cat”);
    }
    public static void main(String[] args) {
    Cat cat=new Cat();
    }
    }
    Animal编译通过,cat编译失败

    展开全文
  • 泛型接口/抽象类 的实现

    千次阅读 2019-09-07 12:41:55
    实现包含了泛型接口或者抽象类有三种方式: 1.不使用泛型,而是默认Object 2.实现接口或父类时,将泛型确定 3.子类继承为泛型类,延迟到实现类时确定泛型 参考代码: 主函数: public static void main(String[]...

    欲实现包含了泛型的接口或者抽象类有三种方式:

    1.不使用泛型,而是默认Object
    2.实现接口或父类时,将泛型确定
    3.子类继承为泛型类,延迟到实现类时确定泛型

    参考代码:

    主函数:
    public static void main(String[] args) {
    		ImpClass1 c1=new ImpClass1();
    		c1.show("abc");
    		c1.show(new Dog());
    		
    		ImpClass2 c2=new ImpClass2();
    		c2.show("abc");
    		//c2.show(new Dog());
    		
    		ImpClass3<Dog> c3=new ImpClass3<Dog>();
    		c3.show(new Dog());
    	}
    
    类和接口:
    class Dog{
    	
    }
    interface Inter<T>{
    	public abstract void show(T t);
    }
    
    class ImpClass1 implements Inter{
    
    	@Override
    	public void show(Object t) {
    		// TODO Auto-generated method stub	
    	}
    	
    }
    class ImpClass2 implements Inter<String>{
    
    	@Override
    	public void show(String t) {
    		// TODO Auto-generated method stub
    	}
    }
    
    class ImpClass3<T> implements Inter<T>{
    
    	@Override
    	public void show(T t) {
    		// TODO Auto-generated method stub
    	}
    }
    
    展开全文
  • 笔者在实际生产中有时会遇到需要自己生成 serviceImpl的 方法,和需要用到工厂类的情况,下面先讲讲怎么用反射做工厂类, 抽象父类 动作被抽象出来 public interface PayStrategy { void pay(double total); ...

    目录

    笔者在实际生产中有时会遇到需要自己生成 serviceImpl的 方法,和需要用到工厂类的情况,下面先讲讲怎么用反射做工厂类,

    抽象父类

    动作被抽象出来

    public interface PayStrategy {
    
        void pay(double total);
    
    }

    实现类

    public class EbankPay implements PayStrategy {
    
        public void pay(double total) {
            System.out.println("pay with ebankpay: " + total);
        }
    
    }

    枚举类

    public enum SectionEnum {
    
        alipay("com.xx.install.calc.model.alipay"),
        wechatpay("com.xx.install.calc.model.wechatpay"), 
        applepay("com.xx.install.calc.model.applepay");
    
        SectionEnum(String className) {
            this.setClassName(className);
        } 
        private String className;
    
        public String getClassName() {
            return className;
        }
    
        public void setClassName(String className) {
            this.className = className;
        }
    
    }

    生产方法

    利用反射获得父类

    public class StrategyFactory {
    
        public static PayStrategy getStrategy(String strategyType) throws Exception {
            String className = SectionEnum .valueOf(strategyType).getClassName();
            return (PayStrategy) Class.forName(className).newInstance();
        }
    
    }

    当然以上只是在工具类中适用,真正的 实际中可能会有 导出报表时,实现类中有大量的 注入的service,所以工具类的这一套就需要稍微换一换

    获取beans的类

    
    
    /**
     * Description: 工具类,用于普通类获取注册过的Bean 
     *
     */
    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.beans.BeansException;
    import org.springframework.beans.factory.NoSuchBeanDefinitionException;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.ApplicationContextAware;
    import org.springframework.stereotype.Component;
    
    @Component
    public class SpringContextUtil implements ApplicationContextAware {
        private final static Logger logger = LoggerFactory
                .getLogger(SpringContextUtil.class);
    
        private static ApplicationContext applicationContext; // Spring应用上下文环境
    
        // 下面的这个方法上加了@Override注解,原因是继承ApplicationContextAware接口是必须实现的方法
        @Override
        public void setApplicationContext(ApplicationContext applicationContext)
                throws BeansException {
            this.applicationContext = applicationContext;
        }
    
        public static ApplicationContext getApplicationContext() {
            return applicationContext;
        }
    
        public static Object getBean(String name) throws BeansException {
            return applicationContext.getBean(name);
        }
    
        public static Object getBean(String name, Class requiredType)
                throws BeansException {
            return applicationContext.getBean(name, requiredType);
        }
    
        public static Object getBean(Class requiredType)
                throws BeansException {
            return applicationContext.getBean(requiredType);
        }
    
        public static boolean containsBean(String name) {
            return applicationContext.containsBean(name);
        }
    
        public static boolean isSingleton(String name) throws NoSuchBeanDefinitionException {
            return applicationContext.isSingleton(name);
        }
    
        public static Class getType(String name)    throws NoSuchBeanDefinitionException {
            return applicationContext.getType(name);
        }
    
        public static String[] getAliases(String name) throws NoSuchBeanDefinitionException {
            return applicationContext.getAliases(name);
        }
    
    } 

    导出的父类

    
    public interface Handle{
    
        @SuppressWarnings("rawtypes")
        public List<Map> handleData(Map<String, String> map);  
    
    }

    实现的子类

    可以使用拼接的名字 ,每一个 导出都会 代入自己的唯一的标识,所以可以 根据传入的标识不一样进行处理

    @Component
    public class M107000015Handle implements Handle{
        private Logger logger = LoggerFactory.getLogger(getClass());
        @Resource
        private ContractService contractService; 
        @SuppressWarnings("rawtypes")
        @Override
        public List<Map> handleData(Map<String, String> map) {
            return contractService.YFQbuildData(map);
        }
    }

    实际使用

    String platCode=dbsource.getname();
    Handle handle = (Handle) SpringContextUtil.getBean(platCode+ "Handle");
    handle.handleData(data);
    展开全文
  • java代码---抽象类的实现

    千次阅读 2018-04-04 15:27:26
    定义一个抽象的"Role"类,有姓名,年龄,性别等成员变量 1)要求尽可能隐藏所有变量(能够私有就私有,能够保护就不要公有), 再通过GetXXX()和SetXXX()方法对...类,该类具有Role类的所有成员(构造方法...
    定义一个抽象的"Role"类,有姓名,年龄,性别等成员变量 
    1)要求尽可能隐藏所有变量(能够私有就私有,能够保护就不要公有), 
    再通过GetXXX()和SetXXX()方法对各变量进行读写。具有一个抽象的play()方法, 
    该方法不返回任何值,同时至少定义两个构造方法。Role类中要体现出this的几种用法。 
    2)从Role类派生出一个"Employee"类,该类具有Role类的所有成员(构造方法除外), 
    并扩展salary成员变量,同时增加一个静态成员变量“职工编号(ID)”。 
    同样要有至少两个构造方法,要体现出this和super的几种用法,还要求覆盖play()方法, 
    并提供一个final sing()方法。 
    3)"Manager"类继承"Employee"类,有一个final成员变量"vehicle" 

    在main()方法中制造Manager和Employee对象,并测试这些对象的方法。

    abstract class Role{
    	private String name;                    //私有属性
    	private int age;
    	private String sex;
    	public String info ="i am dad!";
    	public String getName(){
    		return this.name;
    	}
    	public void setName(String name){
    		this.name = name;
    	}
    		public int getAge(){
    		return this.age;
    	}
    	public void setAge(int age){
    		this.age = age;
    	}
    		public String getSex(){
    		return this.sex;
    	}
    	public void setSex(String sex){        //set get方法
    		this.sex = sex;
    	}
    	public abstract void play();            //抽象方法
    	public Role(String name,int age,String sex){
    		this.name = name;
    		this.age = age;
    		this.sex = sex;
    	}
    
    }
    class Employee extends Role{                   //继承
    	private double salary;                 //私有属性
    	private static String ID;
    	public String info = "i am son!";
    	public double getSalary(){
    		return this.salary;
    	}
    	public void setSalary(double salary){
    		this.salary = salary;
    	}
    	public String getID(){
    		return this.ID;
    	}
    	public void setID(String id){
    		this.ID = id;
    	}
    	public Employee(String name,int age,String sex,double salary,String ID){
    		super(name,age,sex);
    		this.salary = salary;
    		this.ID = ID;
    	}
    	public void play(){
    			System.out.println(super.info);
    		System.out.println(this.info);
    	}
    	final void sing(){
    		System.out.println("name:"+this.getName()+
    			"\nsex:"+this.getSex()+
    			"\nage:"+this.getAge()+
    			"\nsalary:"+this.getSalary());
    	}
    }
    class Manager extends Employee{                    //继承
    	final String vehicle;
    	public Manager(String name,int age,String sex,double salary,String ID,String vehicle){
    		super(name,age,sex,salary,ID);
    		this.vehicle = "自行车";
    	}
    }
    public class TestAbstract{                        //主方法
    	public static void main(String[] args) {
    		Employee e = new Employee("GOGING",26,"男",9000,"010");
    		e.play();
    		e.sing();
    		Manager m = new Manager("cleavlove",24,"男",10000,"001"," ");
    		m.play();
    		m.sing();
    		System.out.println("\n\n\n");
    	}
    }


    展开全文
  • OC实战: 抽象类的实现

    千次阅读 2015-09-04 17:01:51
    新博客地址:http://www.veryitman.com/,致力于让开发变得更好! 本篇新地址:... 这里, 假设你已经明白了 * oc 继承. * oc 多态.其实 oc 里面方法...
  • python 抽象类、抽象方法的实现

    千次阅读 2020-10-11 09:51:06
    python 抽象类、抽象方法的实现 抽象基类提供了一种要求子类实现指定协议的方式,如果一个抽象基类要求实现指定的方法,而子类没有实现的话,当试图创建子类或者执行子类代码时会抛出异常。 python 没有抽象类、...
  • 接口、抽象类实现

    千次阅读 2019-04-13 10:49:25
    2. 接口能被类(抽象类和具体类)实现,区别在于抽象类实现接口,可以实现该接口方法,也可以不实现该接口方法;具体类必须实现接口所有方法 3. 接口可以被接口继承,但不允许被类继承 4. 类之间可以相互继承...
  • 但是,一旦将具体类的无参构造器设置访问修饰符为 private 时,抽象类则不可以继承。 抽象类可以有静态的 main 方法。抽象类在面向对象中是被用来描述现实中的抽象事物, 抽象类没有对象概念所以不能被实例化. 但...
  • python抽象类、抽象方法的实现

    千次阅读 2017-12-07 23:58:13
    由于python没有抽象类、接口概念,所以要实现这种功能得abc.py这个类库,具体方式如下:# coding: utf-8 import abc#抽象类 class StudentBase(object): __metaclass__ = abc.ABCMeta @abc.abstractmethod def ...
  • 如果子类不是抽象类,则要求子类一定要实现父类中抽象方法。 接口类继承,如果是一个子接口,可以扩展父接口方法;如果是一个子抽象类,可以部分或全部实现父接口方法;如果子类不是抽象类,则要求子类一定要...
  • 抽象类实现接口

    千次阅读 2018-07-11 22:30:12
    https://www.cnblogs.com/IanI/p/4549851.html众所周知普通类如果实现一个接口,那么普通类需要重写接口中所有方法但是抽象类实现接口,可以完全覆盖/重写 接口中方法,也可只重写接口中某几个方法子类再继承...
  • 父类和子类的问题困扰了我许久。...假如父类是一个抽象类的情况呢? 考虑下面的抽象类edge。 其中edge没有实现也没有定义ForwordConnetc();方法 假如我们的类有ForwordConnection继承Edge呢? 我...
  • 抽象类实现多态

    千次阅读 2016-05-26 21:21:24
    实现多态第二种方法也就是实用抽象类(Abstract),那么虚方法可以实现多态,抽象类也可以实现多态,那么到底什么时候使用抽象类呢当父类中方法不知道如何去实现的时候,可以考虑将父类写成抽象类,将方法写成抽象...
  • 抽象类实现接口作用、意义

    千次阅读 2018-11-06 14:18:00
    但是抽象类实现接口,可以完全覆盖/重写 接口中方法,也可只重写接口中某几个方法 子类再继承抽象类时,子类重写方法即为抽象类中未重写接口中方法。 在Java中,使用抽象类实现接口,并不是毫无作用。相反...
  • 一、继承(抽象类/普通类)类与实现接口区别 1、继承抽象类,必须重写抽象类中所有抽象方法。 2、继承普通类,可以重写也可以不重写父类方法。 3、实现接口则必须实现接口中所有方法。(接口中方法均为抽象...
  • 抽象类和接口的区别  抽象类里面可以有非抽象的方法,接口里只能有抽象方法。  抽象类中的抽象方法声明时不能有大括号,而接口中的所有...抽象类的主要特征在于它包含抽象成员(abstract member),抽象成员是
  • 抽象类可以实现接口

    千次阅读 2011-03-21 17:58:00
    抽象类的父类可以定义明确的带参数构造函数,抽象类也必须继承从而声明该构造函数。 另外抽象类也可以增加定义无参数的构造函数,从而使自己的子类无需声明明确的构造函数。 一。当父类无构造函数时:...
  • 【c#】抽象类的简单实现

    千次阅读 2019-01-22 23:16:14
    上一篇博客讲到了 C# 中的抽象类与抽象方法,对这两个概念不清楚的可以点击下方链接。...抽象方法因为不提供具体的实现,所以没有方法体(一对大括号所包裹的内容),语句以分号结束。 抽象类仅对成员进行声明,但不...
  • 如果抽象类没有实现接口中所有有方法(不用写方法体),那么A类继承抽象类后就必须重写抽象类没有实现的方法。所以为了方便去使用个别方法,可以让抽象类实现接口所用方法(不用写方法体),这样A类就可以...
  • **抽象类可以使用implements关键字实现接口,但又不用在该抽象类实现接口里具体方法(不实现接口具体方法不会报错),那设计抽象类可以使用implements来实现接口有什么意义啊?** 抽象类: public ...
  • golang之抽象类实现

    2020-06-20 21:54:33
    毋庸置疑,golang是一门相当好语言,稍微用得不太顺手地方就是没有语法层面的抽象类支持。但这也不是完全没有解决办法,利用接口和组合继承,可以实现抽象类。 Java中一段抽象类代码如下: public abstract ...
  • 学习struts2时,拦截器接口Interceptor继承了Serializable接口,拦截器抽象类AbstractInterceptor实现了Interceptor接口,在AbstractInterceptor类中却没有声明或定义Serializable中writeobject等其他方法 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 81,611
精华内容 32,644
关键字:

抽象类的实现