static、final、abstract 、interface 、字段、属性、方法、构造器 应用场景分析

【研究生学术英语读写教程翻译 中国科学院大学Unit9】 Unit 9 If Humble People Make the Best Leaders,Why Do We Fall for Charismatic Narcissists? 如果谦逊的人是最好的领导者,为什么我们会爱上魅力型自恋者? 阅读详情

static (对象是静态的)

  • Static 变量不能在方法体中定义,因为,方法体中的变量为局部变量,局部变量存储在动态存储区

  • 静态变量存储在静态存储区,可以认为规定静态变量不能定义在方法体内部。

  • Static方法中不能使用this和super关键字

  • 不能调用非static方法,只能访问所属类的静态成员变量和成员方法 因为当static方法被调用的时候这个类的对象可能还没有被创建,即使已经被创建了,也无法确定调用那个对象的方法,

  • static方法也不能访问非static类型的变量。

final (常量:对象只能一次赋值操作)

示例

public class DefaultResourceLoader implements ResourceLoader {
   //加载资源的类加载器
   @Nullable
   private ClassLoader classLoader;
   # 用于存储注册的协议解析器
   private final Set<ProtocolResolver> protocolResolvers = new LinkedHashSet(4);
   # 缓存已加载的资源
   private final Map<Class<?>, Map<Resource, ?>> resourceCaches = new ConcurrentHashMap(4);
   
复制代码

static 、 final (静态常量:一起使用: 对象为静态且不能修改)

static final 通常定义 一个常数或者字符串反反复复使用时,内存就不会重复申请和释放

示例

(static) 方法是一个很重要的用途是实现单例模式。为了实现这一功能,必须隐藏构造函数,由于构造函数被声明为private,外界无法直接创建这个类型的对象,只能通过该类提供的方法来获取类的对象。要达到这样的目的只能把创建对象的方法上名为static.

private finalstatic SingleTon instance=new SingleTon();
复制代码
/**
* 活动秘钥信息 accessKey为key
*/
public final static Map<String,ShopAccessInfo> SHOP_RSA_MAP = new HashMap<>();


@Component
@ConfigurationProperties(prefix = "prop")
@PropertySource(value = "config/rsa.properties")
public class CustomSecretKeyMap {
   /**
    * 对接秘钥信息
    */
   private List<ShopAccessInfo> shops;

   /**
    * 获取秘钥信息
    * @return
    */
   public List<ShopAccessInfo> getShops() {
       return shops;
   }

   /**
    * 转换秘钥信息
    * @param shops
    */
   public void setShops(List<ShopAccessInfo> shops) {
       if(CollectionUtils.isEmpty(shops)){
           return;
       }

       this.shops = shops;

       for(ShopAccessInfo shop:shops){
           ActivityMapUtils.SHOP_RSA_MAP.put(shop.getAccessKey(),shop);
       }

   }
}


复制代码

abstract

在抽象类,抽象方法本质上是定义接口规范,即规定高层类的接口,从而保证所有子类都有相同的接口实现,这样,多态就能发挥出威力。

  • abstract常常用于修饰类或方法。
  • **写了抽象方法,那么该类前面就要写abstract修饰。
  • 父类是抽象类,子类继承该abstract类时,要么子类也是抽象类,也就是abstract修饰该类; 要么就是重写父类(abstract)的抽象方法。,如果父类没有抽象方法,则不用重写!!!
  • abstract修饰方法就是为了子类重写该方法,抽象方法不能定义为private
  • 抽象类不能创建对象
  • 抽象类是不能被实例化的 实例化实际就是在内存中开辟一块空间用于存储新的产物,即对象。 在抽象类中,子类实例化会先初始化父类,但父类初始化并不是创建一个父类对象,而是把父类中定义的对象相关属性都初始化,因为这些属性子类对象也是拥有的。 所以,为了保证子类对象的完整性,要从最底层的父类开始,逐级初始化,所有初始化都完成后才会产生一个完整的子类对象
    • 初始化一个对象,创建一个对象需要调用该类的构造方法,而构造方法的意义就是给变量初始化
    • 实例化一个对象,java会在内存中生成你new出来的那个类的实例,即对象。然后可以调用这个对象的方法进行操作,获取对象的公共成员等。
    • java实例化有4种方式: 一、用new语句创建对象,这是最常用的创建对象方式。 二、运用反射手段,调用## java.lang.Class.newInstance() 或者java.lang.reflect.Constructor类的newInstance实例化方法。 例如: XML配置文件中,获取具体子类的类名称字符串subCLassName,然后根据获得类名字符串进行实例化。
Class c = Class.foName(subClassName);
User user = (User) c.newInstance(); //不带有任何参数

public Object getNewObject(String className) trows Exception {
	Class tClass = Class.forName(className);
	Object tObject = tClass.newInstance();
	return tObject;
}
复制代码
Class c = Class.foName(subClassName);
Constructor con = c.getConstructor(String.class);
User user = (User) con.newInstance("name");
 
复制代码

三、调用对象的clone方法。

User user1 = new User(1, "mac"); 
User user2 = null; 
user2 = (User) user1.clone();
复制代码

四、运用反序列化机制。 序列化:把对象状态转化为可保持或者传输的格式过程,被序列化的对象必须implments Serializable; 反序列化:把流转换为对象的过程。 远程传输过程中 , 发送各种类型的数据,无论是哪种数据类型,都以二进制序列的形式在网络上传送,发送方需要把这个java对象转换为字节序列,才可以在网络上传送,也就是序列化的过程。

import org.junit.Test;
public class SerializableTest {
 
    @Test
    public void test() throws IOException {
        Person zizhen = new Person ();
        zizhen.age = 31;
        zizhen.s = "自珍";
        
//obj 写入文件
FileOutputStream  fileOutputStream = new FileOutputStream("temp"); ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
objectOutputStream.writeObject(a);
fileOutputStream.close();
            
            //通过文件读取obj
           FileInputStream fileInputStream = new FileInputStream("temp");
            ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
            Person zizhenClone = (A) objectInputStream.readObject();
            fileInputStream.close();
            System.out.println(zizhenClone.age);
            System.out.println(zizhenClone.name);
       
    }
}

  public  class Person implements Serializable {
    int age;
    String name;
}




//抽象类是不能被实例化的
AbstractApplicationContext abstractApplicationContext =new AbstractApplicationContext() {
    @Override
    protected void refreshBeanFactory() throws BeansException, IllegalStateException {
        
    }

    @Override
    protected void closeBeanFactory() {

    }

    @Override
    public ConfigurableListableBeanFactory getBeanFactory() throws IllegalStateException {
        return null;
    }
};
//接口无法被实例化,但是可以被实现。
DefaultResourceLoader  defaultResourceLoader =new DefaultResourceLoader();
 
复制代码
  • 静态方法是不允许被重写。

image.png

  • 如果一个抽象类没有字段,所有方法全部都是[抽象方法]就可以把该抽象类改写为接口(interface)。
// 抽象类Person
publice abstract class Person {
    public abstract void work();
    public abstract void life();
    public abstract void eat();
    /**
     * Subclasses must implement this method to release  their all pressure
     * This method gets invoked by {@link #sleep()} after all other activities,etc: work, life , eat.
     * <p>Should never throw an exception but rather log shut down the brain  failures.
 */
    public abstract void sleep();

 
}
 
}
复制代码

将抽象类改写成接口

publiceinterface Person {
    void run();
    void eat();
}
复制代码
  • 接口(interface)就是比抽象类还要抽象的纯抽象接口,因为它连字段都不能有。
  • 接口定义的所有方法默认都是public abstract的,所以这两个修饰符不需要写出来,写不写效果都一样。
  • 接口无法被实例化,但是可以被实现。一个实现接口的类,必须实现接口内所描述的所有方法,否则就必须声明抽象类。
  • 接口的所有方法都是抽象方法,接口不能定义实例字段。
  • Java中,一个类只能继承自另一个类,不能从多个类继承。而一个类可以实现多个接口。

代码示例

public abstractclass AbstractApplicationContext extends DefaultResourceLoader
      implements ConfigurableApplicationContext {

   /**
    * Name of the MessageSource bean in the factory.
    * If none is supplied, message resolution is delegated to the parent.
    * @see MessageSource
    */
   public static final String MESSAGE_SOURCE_BEAN_NAME = "messageSource";

/**
 * Subclasses must return their internal bean factory here. They should implement the
 * lookup efficiently, so that it can be called repeatedly without a performance penalty.
 * <p>Note: Subclasses should check whether the context is still active before
 * returning the internal bean factory. The internal factory should generally be
 * considered unavailable once the context has been closed.
 * @return this application context's internal bean factory (never {@code null})
 * @throws IllegalStateException if the context does not hold an internal bean factory yet
 * (usually if {@link #refresh()} has never been called) or if the context has been
 * closed already
 * @see #refreshBeanFactory()
 * @see #closeBeanFactory()
 */
@Override
public abstract ConfigurableListableBeanFactory getBeanFactory() throws IllegalStateException;

}
复制代码

abstract static 不能 组合起来修饰方法

  • abstract修饰的方法无方法体,不能随着类的加载而加载到方法区
  • static修饰的方法随着类的加载会被加载到类的方法区;
  • abstract还不能与final同时存在,因为final修饰的方法是最终方法,无法被重写,abstract 里面的抽象方法 目的是被派生类重写;
  • abstract不能与private同时存在,因为private修饰的方法不可见,无法重写;

interface

  • 如果一个抽象类没有字段,所有方法全部都是[抽象方法]就可以把该抽象类改写为接口(interface)。
  • 接口(interface)就是比抽象类还要抽象的纯抽象接口,因为它连字段都不能有。
/**
 * Used to dereference a {@link FactoryBean} instance and distinguish it from beans <i>created</i> by the FactoryBean. (用于取消引用{@link FactoryBean}实例,区分 FactoryBean 创建的Bean)
 For example, if the bean named
{@code myJndiObject} is a FactoryBean, getting {@code &myJndiObject} will return the factory, not the instance returned by the factory.(如果名为{@code myJndiObject}是一个FactoryBean,正在获{@code&myJndiObject}将返回工厂,而不是工厂返回的实例)
 */
 
public interface BeanFactory {
//常量:如果我们在获取Bean的时候,使用&则获取的是FactoryBean本身对象,否则是获取getObject的代理对象。
    String FACTORY_BEAN_PREFIX = "&";
    Object getBean(String var1) throws BeansException;
...
}
复制代码
  • 接口定义的所有方法默认都是public abstract的,所以这两个修饰符不需要写出来,写不写效果都一样。
  • 接口无法被实例化,但是可以被实现。一个实现接口的类,必须实现接口内所描述的所有方法,否则就必须声明抽象类。
  • 接口的所有方法都是抽象方法,接口不能定义实例字段。
  • Java中,一个类只能继承自另一个类,不能从多个类继承。而一个类可以实现多个接口。
// 抽象类Person
publice abstract class Person {
    public abstract void work();
    public abstract void life();
    public abstract void eat();
    /**
     * Subclasses must implement this method to release  their all pressure
     * This method gets invoked by {@link #sleep()} after all other activities,etc: work, life , eat.
     * <p>Should never throw an exception but rather log shut down the brain  failures.
 */
    public abstract void sleep();

}
复制代码

将抽象类改写成接口

publiceinterface Person {
    void run();
    void eat();
}
复制代码

interface default方法

实现类可以不必覆写default方法。

  • default方法的目的是,当需要给接口新增一个方法时,会涉及到修改全部子类。
  • 如果新增的是default方法,那么子类就不必全部修改,只需要在需要覆写的地方才去覆写新增方法。
  • default方法和抽象类的普通方法是有所不同的,因为interface没有字段,default方法无法访问字段,而抽象类的普通方法可以访问实例字段。

代码示例

interfacePerson {
    void eat();
    String sleep();
}
// 将sleep()方法改为default方法
interface Person {
    String eat();
    default void sleep() {
        System.out.println(  "默认睡觉时间 0:00- 8:00 run");
    }
}
复制代码

Java8新特性定义一个扩展方法:

public interfaceFormula {
    double calculate(int a);
    default double sqrt(int a){
        return Math.sqrt(a);
    }
}
 
public class Bootstrap {
    public static void main(String[] args){
        Formula formula = new Formula(){
            public double calculate(int a){
                return sqrt(a * 100);
            }
            // 原本应该实现的sqrt方法由于新特性的出现,变得不再那么冗余了
        };
        System.out.println(formula.calculate(100));    
        System.out.println(formula.sqrt(16));
    } 
}
 

复制代码

通过该特性,我们将能够很方便的实现接口默认实现类。这个特性在编译器实现的角度来说更接近于Scala的trait。

interface 接口的继承

一个interface可以继承另一个interface,interface继承自interface使用extends,它相当于扩展了接口的方法。

代码示例:

/**
 * SPI interface to be implemented by most if not all application contexts.(SPI接口将由大多数(如果不是所有)应用程序上下文实现。)
 * Provides facilities to configure an application context in addition(此外,还提供配置应用程序上下文的工具)
 * to the application context client methods in the
 * {@link org.springframework.context.ApplicationContext} interface.
 *(继承 ApplicationContext接口中的应用程序上下文客户端方法)
 * <p>Configuration and lifecycle methods are encapsulated here to avoid
 * making them obvious to ApplicationContext client code. The present
 * methods should only be used by startup and shutdown code.
 *
 * @author Juergen Hoeller
 * @author Chris Beams
 * @author Sam Brannen
 * @since 03.11.2003
 */
 
public interface ConfigurableApplicationContext extends ApplicationContext, Lifecycle {
    String CONFIG_LOCATION_DELIMITERS = ",; \t\n";
    String CONVERSION_SERVICE_BEAN_NAME = "conversionService";
    String LOAD_TIME_WEAVER_BEAN_NAME = "loadTimeWeaver";
    String ENVIRONMENT_BEAN_NAME = "environment";
    String SYSTEM_PROPERTIES_BEAN_NAME = "systemProperties";
    String SYSTEM_ENVIRONMENT_BEAN_NAME = "systemEnvironment";

    void setId(String var1);

    void setParent(ApplicationContext var1);

    ConfigurableEnvironment getEnvironment();

    void setEnvironment(ConfigurableEnvironment var1);

    void addBeanFactoryPostProcessor(BeanFactoryPostProcessor var1);

    void addApplicationListener(ApplicationListener<?> var1);

    void refresh() throws BeansException, IllegalStateException;

    void registerShutdownHook();

    void close();

    boolean isActive();

    ConfigurableListableBeanFactory getBeanFactory() throws IllegalStateException;
}
 
复制代码

抽象类和接口区别

Java的接口特指interface的定义,表示一个接口类型和一组方法签名。而编程接口泛指接口规范,如:方法签名,数据格式,网络接口等
复制代码

抽象类和接口区别: 抽象类(abstract class): 继承:只能extends一个class 字段:可以定义实例字段 抽象方法:可以定义抽象方法 非抽象方法:可以定义非抽象方法 接口(interface): 继承:可以extends多个interface& 可以implements多个interface 字段:不能定义实例字段 抽象方法:可以定义抽象方法 非抽象方法:可以定义default方法

1、面向对象特性:重载重写、继承、多态、反射

2、常见关键字 final、static、abstract、finalize、transient、native

3、StringBuffer、StringBuilder 和 String、字符常量池

4、六大设计原则、常见的设计模式(代理、工厂、单例、装饰者、观察者)

5、异常、常见的异常类

6、序列化

7、深拷贝和浅拷贝、值传递和引用传递

8、抽象类和接口

9、基本类型的默认值和取值范围以及字节数

字段 field、 构造器 constructor、 属性(properties)(类属性、实例属性)、变量 (variable)、方法(method)、内部类(inner class) 有什么区别?

属性 :修饰符 数据类型 (属性类型)属性名 = 初始化值 ;

  • Java中的属性(property),通常可以理解为get、set方法、is方法。
  • 属性实现了字段的封装,属性有get、set 方法来控制字段,供外部访问

Java中的属性,其实是相对于JavaBean来说的。所以在Java中,正确的说法应该是JavaBean中有XXX属性,Java类中有OOO字段或成员变量。属性的英文翻译是property

BeanInfobeanInfo = Introspector.getBeanInfo(UserInfo.class);
PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
for (PropertyDescriptor propertyDescriptor : propertyDescriptors) {
    System.out.println(propertyDescriptor.getName());
}
复制代码

如上代码就会输出UserInfo类对应的JavaBean的所有属性名

public abstract class AbstractApplicationContext extends DefaultResourceLoader implements ConfigurableApplicationContext, DisposableBean {

    //常量
    public static final String MESSAGE_SOURCE_BEAN_NAME = "messageSource";

    //字段
    private String id;
    private String displayName;
    private ApplicationContext parent;
    private final List<BeanFactoryPostProcessor> beanFactoryPostProcessors;
    private long startupDate;
    private boolean active;
    private boolean closed;
    private final Object activeMonitor;
    private final Object startupShutdownMonitor;
    private Thread shutdownHook;
    private ResourcePatternResolver resourcePatternResolver;
    private LifecycleProcessor lifecycleProcessor;
    private MessageSource messageSource;
    private ApplicationEventMulticaster applicationEventMulticaster;
    private Set<ApplicationListener<?>> applicationListeners;
    private ConfigurableEnvironment environment;

 
   //属性 对应的方法
    public void setId(String id) {
        this.id = id;
    }
    //属性 对应的方法
    public String getId() {
        return this.id;
    }
    
//属性 对应的方法
    public void setDisplayName(String displayName) {
        Assert.hasLength(displayName, "Display name must not be empty");
        this.displayName = displayName;
    }
//属性 对应的方法
    public String getDisplayName() {
        return this.displayName;
    }


//属性 对应的方法
public boolean isRunning() {
    return this.getLifecycleProcessor().isRunning();
}
//属性 对应的方法
@Override
public String getApplicationName() {
   return "";
}
 //属性 对应的方法
/**
 * Return the list of statically specified ApplicationListeners.(返回静态指定的applicationlistener的列表。)
 */
public Collection<ApplicationListener<?>> getApplicationListeners() {
   return this.applicationListeners;
}

 //方法
public void start() {
    this.getLifecycleProcessor().start();
    this.publishEvent(new ContextStartedEvent(this));
}
 //方法
public void stop() {
    this.getLifecycleProcessor().stop();
    this.publishEvent(new ContextStoppedEvent(this));
}

 
 


复制代码

字段

  • 字段(field),通常叫做“类成员”,或 "类成员变量”,有时也叫“域”,理解为“数据成员”,用来承载数据的。
  • Java中字段的含义就是Java类中定义的成员变量,可以通过Java的反射机制获取所有的字段名,Class#getFields()方法或者Class#getDeclaredFields()方法,看出field其实就是字段的意思。

image.png

public abstract class AbstractApplicationContext extends DefaultResourceLoader implements ConfigurableApplicationContext, DisposableBean {

    //////常量const
    public static final String MESSAGE_SOURCE_BEAN_NAME = "messageSource";
    public static final String LIFECYCLE_PROCESSOR_BEAN_NAME = "lifecycleProcessor";
    public static final String APPLICATION_EVENT_MULTICASTER_BEAN_NAME = "applicationEventMulticaster";
    protected final Log logger;
    
    ///////字段 field
    private String id;
    private String displayName;
    private ApplicationContext parent;
    private final List<BeanFactoryPostProcessor> beanFactoryPostProcessors;
    private long startupDate;
    private boolean active;
    private boolean closed;
    private final Object activeMonitor;
    private final Object startupShutdownMonitor;
    private Thread shutdownHook;
    private ResourcePatternResolver resourcePatternResolver;
    private LifecycleProcessor lifecycleProcessor;
    private MessageSource messageSource;
    private ApplicationEventMulticaster applicationEventMulticaster;
    private Set<ApplicationListener<?>> applicationListeners;
    private ConfigurableEnvironment environment;
复制代码

方法 (method,函数)

变量 (接口里面为常量)

  • 在方法体外,类体内声明的变量称为成员变量。
  • 在方法体内部声明的变量称为局部变量。

image.png

属性和字段区别:

Java中的属性(property),通常可以理解为get和set方法。更形象的说就是:属性是对字段的封装,供外部访问。 而字段(field),通常叫做“类成员”,或 "类成员变量”,有时也叫“域”,理解为“数据成员”,用来承载数据的。

JavaBean的属性名其实就是Java类中定义的setter或者getter方法名,去掉set或者get或者is得到的字符串,判断首字母是否是小写,如是,则该字符串就是属性名,否则再判断第二个字母是否是大写,如是,则该字符串就是属性名,否则将首字母小写得到的名称就是属性名,比如getDizhi()方法属性名就是dizhi,getdizhi()方法属性名也是dizhi,getdIzhi()方法属性名就是dIzhi,getDIzhi()方法属性名就是DIzhi,其中bool类型的属性的get方法名不是以get开头,而是以is开头。

对于只有get或者只有set方法的属性,我们就说他是只读或只写属性。之所以规定Java的字段定义不准以is开头且首两个字母要么都大写要么都小写,就是为了让JavaBean的属性名与字段名一致。

来源:https://juejin.cn/post/7167723266474246180
北京理工大学计算机学院赵曜,中国进出口银行2016年度拟接收毕业生情况公示... 《中国进出口银行2016年度拟接收毕业生情况公示》由会员分享,可在线阅读,更多相关《中国进出口银行2016年度拟接收毕业生情况公示(5页珍藏版)》请在技术文库上搜索。1、二级(三级)单位二级(三级)单位姓名姓名性别性别学历学历毕业学校毕业学校专业专业 中国进出口银行总行 机关 许凯男硕士研究生北京大学法学 中国进出口银行总行 机关 冯晨男硕士研究生北京大学教育技术学 中国进出口银行总行 机关 刘鹏... 阅读详情

相关推荐

手把手教你用89C52单片机驱动0.96寸OLED(IIC接口,附完整代码)

本文详细介绍了如何使用89C52单片机通过I2C接口驱动0.96寸OLED显示屏,包括硬件连接、I2C通信原理、SSD1306驱动芯片的初始化及显存管理技巧,并提供了完整的代码示例和常见问题排查方法,帮助电子爱好者快速掌握OLED显示技术。

weixin_30781433的博客 372

..........

一、什么是抽象类 由abstract修饰的方法叫抽象方法;由abstract修饰的类叫抽象类。抽象的类无法进行实例化,因为他不是具体存在的类,或者说这样的类还不够完善,不能直接使用new关键字调用其构造器生成该类的对象。我们可以使用abstract定义一个抽象类和抽象方法,示例代码如下: abstract class 类名 { abstract int 方法名(int x,int y); } 抽象的方法没有方法体。需要注意的是在抽象类中既可以有抽象方法,也可以有普通方法,注意抽象方法是没有方法体的(也就是方

tjp1234569的博客 344

交叉编译Qt6.5.3(RK3568开发板)

注意,如果使用其它版本的交叉编译器的话,请确保你的交叉编译器能够支持 C++17标准。为确保后续交叉编译没问题,需要确保开发板使用的GLIBC版本不小于2.34版本。到 linaro 网站上下载交叉编译工具,我下载的是 gcc-linaro-11.3.1-2022.06-x86_64_aarch64-linux-gnu.tar.xz。安装 CMake ,最低要求3.16版本,如果要静态编译,需要3.21及以上版本。我使用的3.27版本。:指定为最后交叉编译后的Qt6.5.3库的安装目录。

m0_46309425的博客 5105

static 和 interface的关系

static 和 interface的关系:1)内部接口是隐式的静态的,不管你是不是用static来修饰注意:内部接口很少用到2)外部接口不能是静态的,就像外部类3)接口的所有的成员(属性与方法)是隐式的public的。4)接口中所有的属性是隐式的static和final的5)接口中所有的方法不能定义为static6)接口中所有的被定义的类都是隐式的static的

可乐的专栏 1921

Xilinx Vitis 2020.1头文件路径配置避坑指南:解决#include找不到文件的常见问题

本文针对Xilinx Vitis 2020.1开发环境中常见的#include头文件找不到问题,提供了系统的避坑指南。文章深入解析了Vitis的头文件搜索机制,对比了通过工程属性GUI、修改编译命令及使用环境变量三种配置方法的优劣与隐藏陷阱,并给出了高级场景的排查流程与工程结构最佳实践,帮助开发者高效解决路径配置难题。

weixin_28831399的博客 573

C/C++ LMS算法详解及源码

LMS(Least Mean Squares)算法是一种自适应滤波器算法,用于估计一个系统的参数,以使输出信号与期望信号之间的均方误差最小化。LMS算法通过使用梯度下降的方法,逐步调整自适应滤波器的权值来优化滤波效果。

希望我的博客,能帮上你解决学习中工作中所遇到的问题 3281

private和final的讲解以及一些例子

依据哈工大软件构造lab2的棋牌游戏对private和final的讲解

weixin_45842420的博客 4525

使用 MATLAB/Simulink + Simscape Electrical + Simulink Design Optimization,构建一个沙漠环境中光伏组件灰尘积累与效率下降仿真模型

本文通过,构建了沙漠环境中光伏组件灰尘积累与效率下降仿真模型✅ 建立了风速-沙尘-积尘速率的物理关系✅ 仿真了灰尘积累过程及其对Isc 和 Pmax的影响✅ 量化分析了不同清洁策略的经济性✅ 提出了优化设计与智能运维建议。

xiaoheshang_123的博客 125

谈一谈我眼中的常见修饰符(private,final,static)

1 final的概念 继承的出现提高了代码的复用性,并方便开发。但随之也有问题,有些类在描述完之后,不想被继承,或者有些类中的部分方法功能是固定的,不想让子类重写。可是当子类继承了这些特殊类之后,就可以对其中的方法进行重写,那怎么解决呢? 要解决上述的这些问题,需要使用到一个关键字final,final的意思为最终,不可变。final是个修饰符,它可以用来修饰类,类的成员,以及局部变量。

qiten007的博客 6727

PostgreSQL:Patroni 高可用架构,基于etcd的自动故障转移集群

本文详细介绍了基于Patroni和etcd构建PostgreSQL高可用集群的方案。Patroni作为外部守护进程,通过etcd分布式协调服务实现自动故障转移、主节点选举等关键功能,弥补了PostgreSQL原生缺乏自动故障转移的不足。文章涵盖核心架构(3节点PG+3节点etcd)、环境规划、etcd集群部署(包括配置验证)以及Patroni安装配置的关键步骤,特别强调了Patroni自动初始化PG实例、配置同步复制等生产级特性。该方案通过外部组件协同工作,在不修改PG源码的情况下实现了生产环境所需的高可用

数据知道的博客 2495

SAP Clean Core 对传统 ABAP 开发人员来说意味着什么:机遇和挑战

SAP Clean Core是一种战略方法,旨在优化和现代化 SAP S/4HANA 系统,通过尽量减少定制,确保核心系统的稳定性、高效性和对云环境的兼容性。Clean Core 作为一种设计思路,致力于让 ERP 系统的核心功能保持简洁、规范,避免不必要的复杂化,最终维持一个标准化的核心,使系统更容易升级、性能更优越,同时支持快速的创新能力。

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 615

interface中的static方法和default方法

目前所在的公司用的是JDK8,并且在开发和框架中用了大量的JDK8的新特性,Stream方法就是接口Collection中的default方法。这篇文章整理一下JDK8中对于Interface的改进和升级。中为新增了一项功能,可以在Interface中定义一个或者更多个静态方法,用法和普通的static方法一样。代码示例: 测试: 结果: 实现接口的类或者子接口不会继承接口中的静态方法。JDK8中的另一个特性就是在接口中增加default方法, 是为了既有的成千上万的Java类库的类增加新的功能, 且不必对

科技互联网领域深度探索者,乐于分享与写作。 2020

1.1、matlab:基于模板匹配的车牌识别

matlab:基于模板匹配的车牌识别

XU157303764的博客 2917

abstract、static、final、interface关键字的使用

abstract、static、final关键字的使用

大圣归来圣骑士清欢的博客 355

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

Java中final与static关键字

一.final总结 1.final修饰类:表示该类不可继承 final不能修饰interface接口 2.final修饰方法:表示该方法不能被 子类覆盖(即子类不能重写父类的final方法,可以继承) final不能修饰构造函数 3.final修饰字段属性:表示属性值第一 次初始化后不能被修...

xiaoyaGrace的博客 285

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

static,final,abstract,interface,extends的作用和区别

接口是一种规范,定义了一组方法的签名,但没有具体的实现。类可以实现一个或多个接口,实现接口的类必须实现接口中定义的所有方法。关键字用于指示成员(方法、字段、嵌套类)属于类本身而不是实例。静态成员可以通过类名直接访问,无需创建类的实例。关键字用于指示类或方法是抽象的。抽象方法没有具体的实现,必须在子类中被重写。这些只是java方法中一些修饰符,他们用于定义类、方法、变量等。关键字用于指示成员(方法、字段、类)是不可修改的。关键字用于表示一个类实现了一个或多个接口。关键字用于表示一个类继承自另一个类,

Feixiangdechenyu的博客 274

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

Java中this和super、final和static、abstract和interface关键字的用法详细总结

????一、this二、super三、final四、static五、抽象类和接口的异同点 一、this this是代表当前对象的引用 我们会发现在构造函数的内部,我们可以使用this关键字,构造函数是用来构造对象的,对象还没有构造好,我们就使用了this,那this还代表当前对象吗?当然不是,this代表的是当前对象的引用。 一个对象的产生分为几步? ①为对象分配内存 ②调用合适的构造方法。(构造方法不止一个)那么既然对象产生分两步,必须把两步骤完成,第二步走完之后才会产生对象,而产生对象的过程中就用th

cheng 884

java static 修改_java修改static final常量值

public class EverythingIsTrue {static void setFinalStatic(Field field, Object newValue) throws Exception {field.setAccessible(true);Field modifiersField = Field.class.getDeclaredField("modifiers");mod...

weixin_32256355的博客 1484

黑马程序员——this,super,interface,final,abstract,static

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ------- this,super,interface,final,abstract,static 1、this 对象的引用(静态方法中没有this关键字) 只能在方法内部使用,表示对“调用方法的那个对象”的引用,如果是在同一个类中调用另外一个方法,则可以不用写this,直接调用就行 用法: 1、

hyzhw1992的博客 391

JAVA 构造器, extends[继承], implements[实现], Interface[接口], reflect[反射], clone[克隆], final, static, abstrac

记录一下: 构造器[构造函数]: 在java中如果用户编写类的时候没有提供构造函数,那么编译器会自动提供一个默认构造函数.它会把所有的实例字段设置为默认值:所有的数字变量初始化为0;所有的布尔变量设置为false;所有对象变量设置为null; PS: 只有在类中没有其它构造器的时候,系统才会提供默认构造器.如果你希望用户能能够调用不带参数的构造器,那么你就必须自己实现一个.

1358

JAVA 构造器,extends[继承],implements[实现],Interface[接口],reflect[反射],clone[克隆],final,static,abstract[抽象]

构造器[构造函数]: 在java中如果用户编写类的时候没有提供构造函数,那么编译器会自动提供一个默认构造函数.它会把所有的实例字段设置为默认值:所有的数字变量初始化为0;所有的布尔变量设置为false;所有对象变量设置为null; PS: 只有在类中没有其它构造器的时候,系统才会提供默认构造器.如果你希望用户能能够调用不带参数的构造器,那么你就必须自己实现一个. extends[继

iamcxl 4890

java.lang.reflect.Modifier字段与方法

&amp;gt;一、相关字段 &amp;gt;`static int ABSTRACT` &amp;gt;`表示abstract 修饰符的值。` &amp;gt;`static int FINAL` &amp;gt;`表示final 修饰符的值。` &amp;gt;`static int INTERFACE` &amp;gt;`表示interface 修饰符的值。` &amp;gt;`static int NATIVE` &am

书香水墨 308

java abstract 变量_Java中类、方法和变量修饰符关键字

1、abstract声明抽象abstract关键字可以修改类或方法。abstract类可以扩展(增加子类),但不能直接实例化。abstract方法不在声明它的类中实现,但必须在某个子类中重写。采用abstract方法的类本来就是抽象类,并且必须声明为abstract。2、class类class关键字用来声明新的Java类,该类是相关变量和/或方法的集合。类是面向对象的程序设计方法的基本构造单位。类...

weixin_31227315的博客 586

Java overload、override、interface、abstract、static和多态

一 override 1 方法签名相同,参数相同,返回值相同则是override 2 *用final修饰的方法不能被override.(用final修饰的类也不能被继承,final修饰的字段被初始化后不能再修改) 二 overload 1 overload是一个新方法,方法签名可以不同,参数可以不同,返回值可以不同 三 多态 1 运行期才能决定调用的子类方法 2 作用:允许添加更多子类进行功...

weiqu4386的博客 255

Java面向对象

抽象的用来修饰:类、方法类:抽象类:不能实例化。方法:抽象方法:没有方法体,必须由子类实现此方法。

lvzihao1314的博客 713

SpringBoot:Java 访问修饰符 + 非访问修饰符全景梳理详解/private、default、protected、public

本文系统梳理了Java修饰符在Spring开发中的核心应用,分为四大模块: 访问权限修饰符(private/default/protected/public)的层级控制与Spring场景适配 Java原生非访问修饰符(static/final/abstract等)与Spring注解的联动规则 Spring专属语义修饰(如@Autowired与final组合的构造器注入最佳实践) 分层架构下各组件(Controller/Service/Mapper等)的修饰符标准化配置 重点包含: 静态变量与依赖注入的冲突禁

snow的博客 421
上一篇: mysql巧妙化解递归查询树形数据 | 纯sql
下一篇: 缓存穿透、缓存雪崩、缓存击穿?再也不怕了,你随便问吧!
码趣资源网
博客等级 码龄4年 269粉丝 518原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值