精华内容
下载资源
问答
  • 修饰东西
    2022-03-14 11:08:57

    static可以用来修饰
                成员变量
                    静态变量,可以直接通过类名访问
                成员方法
                    静态方法,可以直接通过类名访问
                代码块
                      静态代码块,当Java虚拟机加载类时,就会执行该代码块
                      如果有多个静态块,按顺序加载,每个静态代码块只会被执行一次
     

    静态方法中不能使用this和super
                不能直接访问所属类的实例变量和实例方法
                可直接访问类的静态变量和静态方法

    更多相关内容
  • synchronized可以用来同步静态和非静态方法,下面就具体来看一下Java中synchronized关键字修饰方法同步的用法详解:
  • 2.final可以修饰变量、方法、类 -final修饰的变量,一旦赋值不能重新赋值 -final修饰的方法无法被覆盖,被重写 -final修饰的类无法继承 -引用也是变量: final Person p1=new Person(20); final修饰的引用只能指向一...

    final是Java语言中的一个关键字(java关键字都小写)
    1.final表示最终的,不可变的
    2.final可以修饰变量、方法、类
    final修饰的类无法继承
    final修饰的方法无法覆盖,重写
    final修饰的变量只能赋一次值
    final修饰的引用一旦指向某个对象,则不能再重新指向其他对象,但该引用指向的对象内部的数据是可以修改的。
    final修饰的实例变量必须手动初始化,不能采用系统默认值。
    final修饰的实例变量一般和static联合使用,称为常量。
    public static final double PI = 3.1415926;

    -引用也是变量: final Person p1=new Person(20); final修饰的引用只能指向一个对象 只有方法结束,p1才能被垃圾回收器回收!
    -final修饰的实例变量,系统不管赋默认值,要求程序员必须手动赋值(在变量后面赋值可以,构造函数里赋值也可以)
    -final修饰的实例变量,一般添加static修饰。因为实例变量在堆中,100个对象100份。因此如果实例变量不会改变,则没必要声明为实例变量,最好是静态的,节省内存。static
    final 联合修饰的变量称为常量(常量名建议全部大写,每个单词之间采用下划线分隔)
    -实际上常量和静态变量一样,区别是常量的指不能变,都存储在方法区,都在类加载时初始化。 -常量一般是公开的:public。

    class User{
    		final int age;
    }
    局部变量是没有初始值的,只能手动赋值;成员变量/实例变量系统会赋默认值。
    实例变量在构造方法执行过在程中赋值
    final class A{   //A没有子孙
    }
    class B extends A{
    }
    String类被final修饰
    
    class C{
    	public final void dosome(){
    			System.out.println("C's doSome....")
    	}
    }
    class D{
    	public void dosome(){
    			System.out.println("D's doSome....")
    	}
    }
    

    在这里插入图片描述

    c/c++跟Java方法传参的区别:
    c public void function(int a[row][col]){
    }//function(a[row][col])
    java public void function(int[][] a){
    }//function(a)
    c 求二位数组的行数和列数:
    int col=sizeof(a[0])/sizeof(int);
    int row=(sizeof(a)/sizeof(int))/(sizeof(a[0])/sizeof(int));
    java:
    a.length();
    a[0].length();

    展开全文
  • 在C#的继承中尝尝会用到相关...对于这两者之间的区别之类的说法,其实网上找到的有很多,大多都是些概念性的东西。我这里主要是对于,自己测试的代码和大家分享下。 using System; public class BaseClass{ public vi
  • java 修饰符总结

    2021-02-28 06:44:15
    java中的修饰符分为类修饰符,字段修饰符,方法修饰符。根据功能的不同,主要分为以下几种。1、权限访问修饰符public,protected,default,private,这四种级别的修饰符都可以用来修饰类、方法和字段(字段就是类成员)。...

    java中的修饰符分为类修饰符,字段修饰符,方法修饰符。根据功能的不同,主要分为以下几种。

    1、权限访问修饰符

    public,protected,default,private,这四种级别的修饰符都可以用来修饰类、方法和字段(字段就是类成员)。default不能修饰变量

    包外         子类          包内           类内

    public      yes        yes          yes         yes

    protected   no         yes          yes         yes

    default     no         no           yes         yes

    private     no         no           no          yes

    2、abstract修饰符

    普通变量不能用abstract修饰,abstract一般修饰方法和类

    abstract是抽象的意思,用来修饰类和方法,修饰类后,该类为抽象类,不能被实例化,必需进行扩展。修饰方法后,该方法为抽象方法必须被子类重写(override)。

    3、native修饰符

    native修饰方法,native修饰的方法简单来说就是:一个Java方法调用了一个非Java代码的接口。

    定义navtive方法时,并不提供实现体,因为其实现体是用非Java语言在外面实现的。native可以和任何修饰符连用,abstract除外。因为native暗示这个方法时有实现体的,而abstract却显式指明了这个方法没有实现体。但是abstract方法和Interface方法不能用native来修饰。

    4、final修饰符

    final的意思是不可变,他可以修饰类、字段、方法。修饰类后类不能被扩展(extends),也就是不能被继承。修饰字段后字段的值不能被改变,因此如果有final修饰字段,应该对字段进行手动初始化。修饰方法后该方法不能被改变,也就是重写。

    final肯定不能与abstract同使时用。

    展开全文
  • Python修饰符 详解

    千次阅读 2020-12-06 14:17:55
      在学习Python的修饰符前,我们要知道几个a概念,首先是Python中的所有东西都是对象,所有我们定义的变量、类甚至与于函数,都是对象。函数是对象是个什么概念呢?就是函数之间可以相互赋值: def first(msg): ...

      修饰符(有的也翻译成装饰符、装饰器,英文叫decorator)是Python中一个很有意思的feature,它可以向已经写好的代码中添加功能。这其实也叫元编程,因为程序的一部分在编译的时候尝试修改程序的另一部分。

    高阶函数

      在学习Python的修饰符前,我们要知道几个a概念,首先是Python中的所有东西都是对象,所有我们定义的变量、类甚至与于函数,都是对象。函数是对象是个什么概念呢?就是函数之间可以相互赋值:

    def first(msg):
    	pritn(msg)
    	
    first("Hello")
    >>> Hello
    
    second = first
    second("Hello")
    >>> Hello
    

      上面的firstsecond都是指向同一个函数对象的。这种直接函数名之间的直接赋值,在C++中是不支持的。

      当然,函数也可以当作参数传递给其他函数,最常见的就是mapfilterreduce这三个函数了。

    def func(x):
    	return x*2
    list(map(func, [1,2,3]))
    >>>[2,4,6]
    
    list(map(lambda x: x * 2, range(1,4)))
    >>>[2,4,6]
    

    下面我们自定义一个函数,其参数也是函数:

    def add(x):
        return x + 1
    
    def test(func, x):
        return add(x)
    

    执行

    test(add, 2)
    >>> 3
    

    在Python中,把其他函数当做参数的函数,叫做高阶函数

    嵌套函数

      就是nested function,在函数中定义函数,这个我们之前写过,直接放上之前的链接:Python嵌套函数 闭包 详解

    Python修饰符

      下面回归正题,来讲Python修饰符。在Python中,使用@来表示修饰符,但这里我们先看下不使用@来完成一个修饰函数。

    def make_pretty(func):
        def inner():
            print("I got decorated")
            func()
        return inner
    
    def ordinary():
        print("I am ordinary")
        
    pretty = make_pretty(ordinary)
    pretty()
    >>> I got decorated
        I am ordinary
    

      在这个例子中,make_pretty()就是一个修饰器,在pretty = make_pretty(ordinary)语句中,ordinary函数被修饰,返回的函数赋值给了pretty。所以修饰器就像对函数又进行了一层的包装,下面来看使用修饰符@来对函数进行修饰,只需在定义函数的上一行加上@func即可。

    def make_pretty(func):
        def inner():
            print("I got decorated")
            func()
        return inner
        
    @make_pretty
    def ordinary():
        print("I am ordinary")
        
    ordinary()
    >>> I got decorated
        I am ordinary
    

      修饰符必须出现在函数定义前一行,不允许和函数定义在同一行。只可以在模块或类定义层内对函数进行修饰,不允许修饰一个类。一个修饰符就是一个函数,它将被修饰的函数做为参数,并返回修饰后的同名函数或其它可调用的东西。

      本质上讲,修饰符@类似于回调函数,把其它的函数作为自己的入口参数,在目的函数执行前,执行一些自己的操作,然后返回目的函数。当Python解释器读取到修饰符时,会调用修饰符的函数,来看下面的例子(这个例子只是为了解释Python读取到修饰符时会直接调用,这个修饰函数并没有返回目的函数)

    # test.py
    def test(func):
        print('This is test function step1')
        func()
        print('This is test function step2')
        
    @test
    def func():
        print('This is func...')
    

    代码打印如下:

    This is test function step1
    This is func...
    This is test function step2
    

    这段代码中只是定义了两个函数,并没有调用它们,但仍然会有结果打印出来。

      当被修饰的函数中含有参数时,应该怎么来写呢?

      我们定义一个除法函数,参数a和b,返回a/b的结果。

    def divide(a,b)
    	return a / b
    

    我们知道除法的除数不能是0,因此当我们令b=0时,就会报错。

    >>> divide(2,5)
    0.4
    >>> divide(2,0)
    Traceback (most recent call last):
    ...
    ZeroDivisionError: division by zero
    

      所以我们需要增加判断机制,当除数为0时,需要告诉用户不能执行。但divide()函数中我们就只想完成除法的功能,判断机制就可以通过修饰符来完成。

    def smart_divide(func):
        def inner(a, b):
            print("I am going to divide", a, "and", b)
            if b == 0:
                print("Whoops! cannot divide")
                return
    
            return func(a, b)
        return inner
    
    @smart_divide
    def divide(a, b):
        print(a/b)
    

    可以看到,在修饰符函数内容的嵌套函数inner()中,嵌套函数的参数依然的(a,b),返回值也同样是func(a,b),这就是包含参数的函数被修饰时的写法。

    divide(2,5)
    >>> I am going to divide 2 and 5
        0.4
    
    divide(2,0)
    >>> I am going to divide 2 and 0
        Whoops! cannot divide
    

    一般的,我们定义函数的参数可以设为*args, **kwargs,其中*args表示位置参数,位置很重要,是以列表形式呈现;**kwargs:关键字参数,位置不重要。字典形式呈现。

    def works_for_all(func):
        def inner(*args, **kwargs):
            print("I can decorate any function")
            return func(*args, **kwargs)
        return inner
    
    @works_for_all
    def ff(*args, **kwargs):
        print(args)
        print(kwargs)
    

    调用示例如下:

    ff(1,2,a=3,b=4)
    >>> I can decorate any function
        (1, 2)
        {'a': 3, 'b': 4}
    

    一个函数的多个修饰符

      Python中,一个函数可以有多个修饰符。

    def star(func):
        def inner(*args, **kwargs):
            print("*" * 30)
            func(*args, **kwargs)
            print("*" * 30)
        return inner
    
    def percent(func):
        def inner(*args, **kwargs):
            print("%" * 30)
            func(*args, **kwargs)
            print("%" * 30)
        return inner
    
    @star
    @percent
    def printer(msg):
        print(msg)
    
    printer("Hello")
    

    打印结果如下:

    ******************************
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    Hello
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    ******************************
    

    其实上面的:

    @star
    @percent
    def printer(msg):
        print(msg)
    

    就等效于下面的写法:

    def printer(msg):
        print(msg)
    printer = star(percent(printer))
    

    因此执行的步骤为:

    • printer函数传入到percent函数中,percent函数直接返回inner函数给star函数
    • star函数中,传入的参数funcpercent的内嵌函数inner,此时在starinner中,先执行print("*" * 30),再执行func(),也就是会进入到percent->inner中执行
    • 此时将执行print("%" * 30),再执行func(),此时的funcprinter
    • 再执行percent->inner中的print("%" * 30),返回后又到了star->inner中,执行print("*" * 30)

    写的有点绕,看下面的图会更加清晰,从左到右执行。

    image-20201201100007361

    总结

      下面来总结一下修饰符的要点:

    1. 修饰符必须出现在函数定义前一行,不允许和函数定义在同一行;
    2. 修饰符的内嵌函数的参数跟被修饰的函数参数相同,内嵌函数的返回值跟被修饰函数的定义表达式一样
    3. 一个函数可以用多个修饰符,执行顺序是参考上图。

    微信公众号:
    在这里插入图片描述

    展开全文
  • 不可以丢失东西。】 以上这篇浅谈php中的访问修饰符private、protected、public的作用范围就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持软件开发网。 您可能感兴趣的文章:php中访问...
  • Vue修饰

    2022-06-07 19:29:30
    Vue修饰
  • const修饰变量

    2022-04-12 23:39:25
    首先我们要知道const是constant的缩写(意思是:恒定不变的),那么const作为C语言的关键字去修饰一个东西所表示的意思就很好猜测了,基本可以确定:被const修饰东西都拥有了恒定不变的属性,这是我们可以确定的。...
  • final关键字用于修饰类 public final class 类名称 { … } 一个类如果是final的,那么其中所有的成员方法都无法进行覆盖重写,java中典型的final修饰的类 String类 作用:使当前这个类不能有任何子类 说明:当用final...
  • Java 修饰

    2019-11-02 15:45:30
    Java语言提供的修饰符主要分为以下两类: 访问修饰符 非访问修饰符 访问修饰符 Java中,可以使用访问修饰符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。 default (即默认): 在...
  • 1、static修饰的变量和方法,在类加载时即被初始化,可直接通过类名.变量名和类型.方法名进行调用。2、static修饰的变量,在类加载时会被分配到数据区的方法区。类的实例可共享方法区中的变量。如果static修饰的变量...
  • 不能用来修饰interface修饰的方法

    万次阅读 多人点赞 2019-04-24 11:02:26
    不能用来修饰interface的有( )(仅限外部接口) 正确答案: A C D A private B public C protected D static 解析: 1、抽象类中的抽象方法(其前有abstract修饰)不能用private、...
  • final可以修饰类、方法、成员变量 当final修饰类的时候,说明该类不能被继承 当final修饰方法的时候,说明该方法不能被重写 在早期,可能使用final修饰的方法,编译器针对这些方法的所有调用都转成内嵌调用,这样...
  • synchronized关键字(一)修饰对象 文章目录synchronized关键字(一)修饰对象一、 synchronized是什么?二、修饰对象三、注意事项 参考文献:https://www.jb51.net/article/226912.htm 一、 synchronized是什么...
  • const修饰指针的效果

    2022-01-21 15:10:41
    const关键字经常用来修饰常量,也就是说当有个变量你不希望改变时,可以用const来修饰 const int num=20; num=30;//错误,const修饰的变量不可改变 2.const与指针 const关键字位置不同,修饰侧重点不同,就会...
  • 本小节详细介绍了 Java 访问修饰符。它们控制 Java 类及其成员(函数和数据)的可见性。它们是公共的、私有的和受保护的。 但是,当没有修饰符存在时,Java 也实现了默认情况。这意味着一个类、它的函数、字段只能...
  • 一、static关键字的作用 1、修饰一个属性 用static关键字修饰变量,变量则变为了全局变量 2、修饰一个方法
  • static修饰成员变量 :如果有数据需要被共享给所有对象使用时,那么就可以使用static修饰。静态成员变量的访问方式:方式1: 可以使用对象进行访问。格式: 对象.变量名。方式二: 可以使用类名进行访问。格式: ...
  • 1、抽象类中的抽象方法(其前有abstract修饰)不能用private、static、synchronized、native访问修饰修饰。 原因如下: 抽象方法没有方法体,是用来被继承的,所以不能用private修饰; static修饰的方法可以通过...
  • 正则表达式——修饰符(标记) 标记也称为修饰符,正则表达式的标记用于指定额外的匹配策略。 标记不写在正则表达式里,标记位于表达式之外,格式如下: /pattern/flags i ignore-不区分大小写 将匹配设置为不区分大...
  • Java基于final修饰数据过程解析

    千次阅读 2021-02-26 16:29:14
    这篇文章主要介绍了Java基于final修饰数据过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下final是Java中的一个重要关键字,它可以修饰数据、方法和类,...
  • private修饰的方法可以被继承,简单的说,子类可以继承父类所有成员变量和属性(内部类除外),包括final或private修饰的,只不过子类继承父类的private属性或方法时,子类不能直接去调用他。但是可以通过从父类继承...
  • 对于本题,我有三点说明,希望看到这个评论的人能从这三点中看到你以前没注意到的东西:①接口的声明,修饰符的使用和类的声明是一致的,(当前,前提类是外部类,不是所谓的内部类),都只能使用public或者什么都不写...
  • Java常用的修饰符关键字

    千次阅读 2021-05-01 16:16:30
    修饰符型关键字 public修饰符:任何类都可以访问 protected修饰符:类及其子类或同一个包下的类可 以访问 default(默认不写):类及当前包下可以访问 private修饰符:访问权限仅限于类内部 static关键字 static变量和...
  • 类、方法、成员变量和局部变量的可用修饰修饰符 类 成员访求 构造方法 成员变量 局部变量 abstract(抽象的) √ √ - - - static (静态的) - √ - √ - public(公共的) √ √ √ √ - ...
  • java中的四种修饰

    2021-03-10 08:44:24
    在编程过程中,经常会遇到四种修饰符来控制访问权限。之前对这个知识点没有研究过,一直是一知半解,每次遇到问题都模棱两可,不能给出一个确切的答案。近几天系统的看了看,也有了自己的一点心得体会。正文:先上...
  • 一、函数修饰

    2021-12-26 19:10:10
     一个修饰符就是一个函数,它将被修饰的函数作为参数,并返回修饰后的同名函数或其他可调用的东西?   要了解python中@装饰器的作用,首先要记住这么几点: 1. 装饰器符号“@”属于语法糖,什么意思呢?就是说...
  • 接口是我们Java开发常用到的,今天我们就来说说关于接口中修饰符的相关知识,一起来看看吧。接口其实就是提供了一种统一”协议”,接口中的属性也属于“协议”中的成员。它们是公共的,静态的,最终的常量。相当于...
  • 1、抽象类中的抽象方法(其前有abstract修饰)不能用private、static、synchronized、native访问修饰修饰。原因如下:抽象方法没有方法体,是用来被继承的,所以不能用private修饰;static修饰的方法可以通过类名...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 141,251
精华内容 56,500
热门标签
关键字:

修饰东西