精华内容
下载资源
问答
  • # 修饰符和关键字有什么不同? 在 《Kotlin 编程实践》 书中看到说 const 是一个修饰符,val 是一个 Kotlin 关键字。 想了解一下 两者有什么不同?
  • (3)不可以是java中的关键字和保留字。(4)标识符字间不能有空格。(5)可由数字,字母下划线(_),美元符号($)或人民币符号(¥)组成,中文也行,很国际化。(6)没有长度限制。(7)不能是true、falsenul...

    一、标识符

    1.概念:标识符好比人和物的姓名,java中标识符就是类、对象、方法、变量、接口和自定义数据类型等等的名字。

    2.规则:

    (1)首位不能是数字。

    (2)标识符对大小写敏感。

    (3)不可以是java中的关键字和保留字。

    (4)标识符字间不能有空格。

    (5)可由数字,字母和下划线(_),美元符号($)或人民币符号(¥)组成,中文也行,很国际化。

    (6)没有长度限制。

    (7)不能是true、false和null。

    3.命名约定:

    (1)类和接口名:每个字的首字母大写,含有大小写。例如,MyDog、YourDog、Student等。

    (2)方法名或变量名:第一个单词首字母小写,从第二个单词开始首字母大写。(小驼峰法)例如,一个单词:首字母小写。如:name、age。多个单词:第二个单词首字母大写。如:stuName、showTime。

    (3)常量名:基本数据类型的常量名使用全部大写字母,单词间用下划线分隔。对象常量可大小混写。例如,MY_DOG、YOUR_DOG等等。

    (4)包名:全部小写,用”.”隔开,每一个点表示一级目录,至少要有一级目录。例如,单级包:小写。如:com。多级包:小写,用”.”隔开。如:com.baidu.www。

    二、修饰符

    java修饰符分两类:访问修饰符和非访问修饰符。

    修饰符用来定义类、方法或者变量,通常放在语句的最前端。

    1.访问修饰符

    种类:

    default(缺省,默认,即什么都不写):在同一包内可见,不使用任何修饰符。       使用对象:类、接口、变量、方法。

    public(公有):对所有类可见。                                                                                     使用对象:类、接口、变量、方法。

    protected(保护):对同一包内的类和所有子类可见。                                                   使用对象:变量、方法。 注意:不能修饰类(外部类)。

    private(私有):在同一类内可见。                                                                                使用对象:变量、方法。 注意:不能修饰类(外部类)。

    访问权限说明:

    修饰符

    当前类

    同一包内的类

    子孙类(同一包)

    子孙类(不同包)

    其他包

    public

    Y

    Y

    Y

    Y

    Y

    protected

    Y

    Y

    Y

    Y/N

    N

    default

    Y

    Y

    Y

    N

    N

    private

    Y

    N

    N

    N

    N

    规则说明:

    (1)default(默认访问修饰符~即不用关键字)

    使用default声明的变量和方法,对同一包内的类是可见的。接口里的变量都隐式声明为public static final,而接口里的方法默认情况下访问权限为public。

    (2)public(公有访问修饰符)

    被声明为 public 的类、方法、构造方法和接口能够被任何其他类访问。

    如果几个相互访问的 public 类分布在不同的包中,则需要导入相应 public 类所在的包。由于类的继承性,类所有的公有方法和变量都能被其子类继承。

    (3)protected(被保护的访问修饰符)

    子类与基类在同一包中:被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问。

    子类与基类不在同一包中:那么在子类中,子类实例可以访问其从基类继承而来的 protected 方法,而不能访问基类实例的protected方法。

    子类能访问 protected 修饰符声明的方法和变量,这样就能保护不相关的类使用这些方法和变量。

    (4)private(私有访问修饰符)

    私有访问修饰符是最严格的访问级别,所以被声明为 private 的方法、变量和构造方法只能被所属类访问,并且类和接口不能声明为 private。

    声明为私有访问类型的变量只能通过类中公共的 getter 方法被外部类访问。

    Private 访问修饰符的使用主要用来隐藏类的实现细节和保护类的数据。

    访问控制和继承:

    父类中声明为 public 的方法在子类中也必须为 public。

    父类中声明为 protected 的方法在子类中要么声明为 protected,要么声明为 public,不能声明为 private。

    父类中声明为 private 的方法,不能够被继承。

    2.非访问修饰符(简单介绍)

    static 修饰符,用来修饰类方法和类变量。

    final 修饰符,用来修饰类、方法和变量,final 修饰的类不能够被继承,修饰的方法不能被继承类重新定义,修饰的变量为常量,是不可修改的。

    abstract 修饰符,用来创建抽象类和抽象方法。

    synchronized 和 volatile 修饰符,主要用于线程的编程。

    三、关键字

    注意:java关键字都是全小写的。

    关键字

    含义

    abstract

    表明类或者成员方法具有抽象属性

    assert

    断言,用来进行程序调试

    boolean

    基本数据类型之一,声明布尔类型的关键字

    break

    提前跳出一个块

    byte

    基本数据类型之一,字节类型

    case

    用在switch语句之中,表示其中的一个分支

    catch

    用在异常处理中,用来捕捉异常

    char

    基本数据类型之一,字符类型

    class

    声明一个类

    const

    保留关键字,没有具体含义

    continue

    回到一个块的开始处

    default

    默认,例如,用在switch语句中,表明一个默认的分支

    do

    用在do-while循环结构中

    double

    基本数据类型之一,双精度浮点数类型

    else

    用在条件语句中,表明当条件不成立时的分支

    enum

    枚举

    extends

    表明一个类型是另一个类型的子类型,这里常见的类型有类和接口

    final

    用来说明最终属性,表明一个类不能派生出子类,或者成员方法不能被覆盖,或者成员域的值不能被改变,用来定义常量

    finally

    用于处理异常情况,用来声明一个基本肯定会被执行到的语句块

    float

    基本数据类型之一,单精度浮点数类型

    for

    一种循环结构的引导词

    goto

    保留关键字,没有具体含义

    if

    条件语句的引导词

    implements

    表明一个类实现了给定的接口

    import

    表明要访问指定的类或包

    instanceof

    用来测试一个对象是否是指定类型的实例对象

    int

    基本数据类型之一,整数类型

    interface

    接口

    long

    基本数据类型之一,长整数类型

    native

    用来声明一个方法是由与计算机相关的语言(如C/C++/FORTRAN语言)实现的

    new

    用来创建新实例对象

    package

    private

    一种访问控制方式:私用模式

    protected

    一种访问控制方式:保护模式

    public

    一种访问控制方式:共用模式

    return

    从成员方法中返回数据

    short

    基本数据类型之一,短整数类型

    static

    表明具有静态属性

    strictfp

    用来声明FP_strict(单精度或双精度浮点数)表达式遵循IEEE 754算术规范[1]

    super

    表明当前对象的父类型的引用或者父类型的构造方法

    switch

    分支语句结构的引导词

    synchronized

    表明一段代码需要同步执行

    this

    指向当前实例对象的引用

    throw

    抛出一个异常

    throws

    声明在当前定义的成员方法中所有需要抛出的异常

    transient

    声明不用序列化的成员域

    try

    尝试一个可能抛出异常的程序块

    void

    声明当前成员方法没有返回值

    volatile

    表明两个或者多个变量必须同步地发生变化

    while

    用在循环结构中

    取材于:菜鸟教程、百度百科。

    展开全文
  • 什么是Java注释访问修饰符 public,private,protected,以及不写(默认)时的区别&&&的区别final 有什么用?final finally finalize区别this关键字的用法super关键字的用法this与super的区别static存在...

    Java语言采用何种编码方案?有何特点?

    1. 采用Unicode编码标准,通过用双字节来表示一个字符,从而在更大范围内将数字代码映射到多种语言的字符集。为每一个字符定义了唯一的数值。
    2. 因此无论是什么平台,什么语言,什么程序都可以放心使用

    什么是Java注释

    1. 用于解释JAVA程序的文字
    2. 分类
      • 单行注释://
      • 多行注释:/**/
      • 文档注释:/** */
    3. 作用:增强代码的可读性,通过注释能够更快的理解程序信息,注释与注释之间不能够嵌套

    访问修饰符 public,private,protected,以及不写(默认)时的区别

    1. public:对所有类公开
    2. private:只对当前类公开
    3. protected:对于同包内的类和子类公开
    4. 不写:对于同包内公开

    &和&&的区别

    1. & 和 && 都可以作为逻辑与
    2. &还可以作为按位与
    3. 如果&&左边的表达式的值是 false,右边的表达式会被直接短路掉,不会进行运算。

    final 有什么用?

    1. 被final修饰的类不可以被继承
    2. 被final修饰的方法不可以被重写
    3. 被final修饰的变量就变成常量
    4. 被final修饰的引用类型,则在其初始化之后便不能指向其他对象了,但是该引用所指向的对象的内容是可以发生变化的。

    final finally finalize区别

    1. final:是一个修饰关键字,修饰类,方法和变量
    2. finally:作用在try-catch代码块中,在处理异常的时候,通常我们将一定要执行的代码方法finally代码块中,表示不管是否出现异常,该代码块都会执行,一般用来存放一些关闭资源的代码。
    3. finalize:是一个方法,属于Object类的一个方法,该方法一般由垃圾回收器来调
      用,当我们调用System.gc() 方法的时候,由垃圾回收器调用finalize(),回收垃圾,一个对象是否可回收的最后判断

    this关键字的用法

    1. this是自身的一个对象,代表对象本身,可以理解为:指向对象本身的一个指针。
    2. 用法:
      • 普通的直接引用,相当于指向当前对象本身
      • 利用this区分形参与成员名字重名
      • 引用本类的构造函数

    super关键字的用法

    1. 指向自己超类(父类)的指针,超类指的是离自己最近的类。
    2. 用法:
      • 可以引用父类的成员或者方法
      • 可以区分与子类名字相同的成员变量和方法

    this与super的区别

    1. 调用成员变量
      • this可以调用本类的成员变量,也可以调用父类的成员变量
      • super只可以调用父类的成员变量
    2. 调用构造方法
      • this调用的本类的构造方法
      • super调用的父类的构造方法
    3. 调用成员方法
      • this可以调用本类的成员方法也可以调用父类的成员方法
      • super只调用父类的成员方法

    static存在的主要意义

    1. 创建独立于具体对象的域变量或者方法。以致于即使没有创建对象,也能使用属性和调用方法!
    2. 用来形成静态代码块以优化程序性能

    static的独特之处

    1. 被static修饰的变量或者方法是独立于该类的任何对象,也就是说,这些变量和方法不属于任何一个实例对象,而是被类的实例对象所共享。
    2. 在该类被第一次加载的时候,就会去加载被static修饰的部分,而且只在类第一次使用时加载并进行初始化,注意这是第一次用就要初始化,后面根据需要是可以再次赋值的。
    3. static变量值在类加载的时候分配空间,以后创建类对象的时候不会重新分配。赋值的话,是可以任意赋值的!
    4. 被static修饰的变量或者方法是优先于对象存在的,也就是说当一个类加载完毕之后,即便没有创建对象,也可以去访问。

    static应用场景

    1. 某个成员变量是被所有对象所共享的,那么这个成员变量就应该定义为静态变量。
    2. 静态代码块
    3. 修饰类【只能修饰内部类也就是静态内部类】
    4. 静态导包

    static注意事项

    1、静态只能访问静态。
    2、非静态既可以访问非静态的,也可以访问静态的。

    break ,continue ,return 的区别及作用

    1. break 跳出总上一层循环,不再执行循环(结束当前的循环体)
    2. continue 跳出本次循环,继续执行下次循环(结束正在执行的循环 进入下一个循环条件)
    3. return 程序返回,不再执行下面的代码(结束当前的方法 直接返回)

    在 Java 中,如何跳出当前的多重嵌套循环

    • 可以在外面的循环语句前定义一个标号,然后在里层循环体的代码中使用带有标号的break 语句,即可跳出外层循环。
     ok:
        for (int i = 0; i < 10; i++) {
            for (int j = 0; j < 10; j++) {
                System.out.println("i=" + i + ",j=" + j);
                if (j == 5) {
                    break ok;
                }
    
            }
    
    

    总结

    转载:JAVA基础面试题
    总的来说还是回忆起之前所学,有些细节的点还是需要翻一翻的

    展开全文
  • 我们说的静态变量非静态变量说的都是成员变量。局部变量不可以用static修饰。 public void m1(){}//非静态方法、实例方法 public static void m2(){}//静态方法、类方法 { System.out.print();//游离块 } ...

    static

    private  int   a;//非静态变量、实例变量、非静态属性

    private  static  int  b;//静态属性、静态变量、类变量

    我们说的静态变量和非静态变量说的都是成员变量。局部变量不可以用static修饰。

    public  void  m1(){}//非静态方法、实例方法

    public  static  void  m2(){}//静态方法、类方法

    {

         System.out.print();//游离块

    }

    static{

         System.out.print();//静态块

    }

    public class Inner{//非静态内部类

    }

    Public  static class Inner

    {//静态内部类

    }

    静态变量和非静态变量的区别:

    静态的方法中,只能直接访问静态的属性和方法

    静态的成分优先于对象存在(数据共享)

     

    静态和非静态方法的区别:

    • 修饰符不同
    • 调用方式不同:静态用类.方法名      非静态用对象.方法名

     

    static块:

    static{//静态游离游离块
    		//静态游离块内容
    	}

    使用static的匿名块时候子类创建对象的执行顺序:父类静态块-->子类静态块-->父类游离块-->父类构造方法-->子类游离块-->子类构造方法

    package com.****;
    
    class Father {
    
    	static {
    
    		System.out.println("Father类中静态块");
    
    	}
    
    	{
    
    		System.out.println("Father类中游离块");
    
    	}
    
    	public Father() {
    
    		System.out.println("father无参构造方法");
    
    	}
    
    }
    
    class Son extends Father {
    
    	static {
    
    		System.out.println("Son类中静态块");
    
    	}
    
    	{
    
    		System.out.println("Son类中游离块");
    
    	}
    
    	public Son() {
    
    		System.out.println("son无参构造方法");
    
    	}
    
    }
    
    public class Demo {
    
    	public static void main(String[] args) {
    
    //什么叫类加载的时候
    
    		Son s1 = new Son();
    
    	}
    
    }

     

    结果如下:

     

    final

    final修饰的类不能被继承

    final修饰的属性不能被子类重写

    final修饰的变量不能被再次赋值

    final修饰的引用类型时,它就不能再指向新的对象(地址),但是它指向的对象的值可以被改变

     


    abstract

    抽象类:被abstract修饰的类。

    抽象类不可以直接创建对象

    什么时候把类定义为抽象类?

    情况1:有抽象方法(被abstract修饰的方法)

            抽象方法是只有声明但是没有方法体的方法。

            抽象方法必须定义在抽象类中。

    情况2:子类继承了父类的抽象类,但是至少有一个抽象方法没有实现,则子类必须定义为抽象类。

    情况3:类实现了接口(接口就是更抽象的抽象类),但是没有实现接口中的所有抽象方法。(和情况2类似)

     

    interface(只能修饰类,称为接口)

    接口使用interface修饰,是比抽象类更抽象的抽象类

    在接口中,只能定义public static fianl修饰的常量和public abstract修饰的抽象类。但是在JDK1.8之后加入了static方法和default方法。加入的好处是为了避免当需要在父类中添加方法时必须重写所有子类的情况。Static和default的方法可以被所有子类调用(static使用接口名.方法名调用,default使用子类对象.方法名)。

     

    接口、类之间的继承模式:

    • 接口与接口是多继承(当有别的类实现多继承的接口时必须实现所有的抽象方法)
    • 类和接口是多实现
    • 类和类是单继承

    一个类可以实现多个接口,但是必须实现接口中的所有抽象方法。当子类实现的多个接口中出现同名default方法时(default方法使用格式是子类对象.方法名,因此出现同名对象时不知道调用那一个),它必须做出”选择”。

     

    接口不可以直接创建对象:

    1.可以通过实现类创建  接口类  接口名=new  实现类();类似子类向上转型

    2.匿名类

    展开全文
  • 在声明@property 属性后,会有两种实现选择@synthesize @dynamic 2. 两者区别 @synthesize ,表示在编译阶段 编译器会自动生成 setter/getter方法; @dynamic,表示通知编译器不自动生成,由用户手动添加...

    一、@property

    1. @synthesize 与 @dynamic
    在声明@property 属性后,会有两种实现选择@synthesize 和 @dynamic

    2. 两者区别

    • @synthesize ,表示在编译阶段 编译器会自动生成 setter/getter方法的实现;
    • @dynamic,表示通知编译器不自动生成,由用户手动添加属性的 setter/getter方法;

    3. @property重写setter方法
    如果使用@property生成的属性,重写setter方法会报错。
    原因: 重写setter方法,那@property就不会再自动生成setter和getter方法,也不会生成带下划线的成员变量,自然无法访问报找不到该对象。
    解决: 使用 @synthesize

       @synthesize object = _object;
    

    二、属性关键字

    1. 默认属性关键字
    默认包含: atomic、 readwrite、assign(基本数据类型)、strong(对象);

    2. 关键字分类

    • 读写权限: readonly、readwrite ;
    • 原子性: atomic、noatomic ;
    • 内存管理: assign, weak, unsafe_unretained, copy, strong,retain;
      注意点
      retain用在MRC,当retain作为@property属性关键字时:
      @property(nonatomic, retain) 相当于系统自动帮我们处理了属性的setter方法,如下
     -(void)setObject:(id)Obj
     {
       if(obj != obj) {    // 防止重复赋值,指针指向被释放的对象造成崩溃
       [_obj release];     // 防止前一个对象没被释放,造成的内存泄漏
       [obj retain];       // 多对象引用,保证A存在B存在,A释放B随后释放
       _obj = obj;
      }
    }
    

    同时注意,在MRC下retain作为关键字,dealloc中都需要把属性进行释放。才能防止内存泄漏。

     -(void)dealloc
     {
      [_obj release];  // ...
      [super dealloc];
    }
    

    三、常见比较

    1. 原子性 atomic 与 nonatomic区别?

    • atomic 是系统默认的属性,给getter/setter方法会进行加锁,在一定程度保证线程安全;
    • nonatomic 没有加锁,不能保证线程安全, 但是访问更快;
    • 设置属性一般会使用 nonatomic , 虽然atomic能保证线程安全但是保护范围仅仅是getter/setter方法,而且耗费资源、访问更慢。

    2. assign 和 weak 的区别?

    • assign 可以修饰基本数据类型, weak用来修饰对象;
    • assign 修饰的对象被释放后,对象对应的指针没有置为 nil 从而造成野指针;
      weak 修饰的对象被释放后,对象指针置为 nil 。

    3. copy 和 strong 的区别?

    • copy分为浅拷贝和深拷贝;
      浅拷贝不会开辟新的地址产生新的对象,两个指针指向同一块地址,因此引用计数+1;
      深拷贝会开辟新的地址产生新的对象,两个指针各自指向不同的地址,因此引用计数不会+1;
    • copy 和 strong的区别
      strong 强引用对象,操作仍是浅拷贝; copy修饰的对象,分深浅拷贝两种;引用计数也有不同;

    4. 为什么代理使用 weak 修饰?

    答:防止循环引用

    • 如以UITableView为例, tableView作为控制器vc的属性, vc 强引用tableView;
      tableView需要设置vc为代理,self.delegate = vc; 如果代理也是强引用则会造成循环引用。 因此代理使用weak;

    5. 为什么 block 使用copy修饰?

    答: Block作为OC对象, 包含 全局Block、 堆Block、栈Block 三种;
    在Block没有访问外部变量时,一般是放在全局区;当需要访问外部变量时,分MRC和ARC两种;

    • MRC下,Block是放在栈中的,会随着作用域的结束被系统收回,当外部变量调用空的对象就会造成崩溃;
      因此使用copy,复制一份在堆内存中,始终强引用防止被销毁;
    • ARC下,系统自动的对block进行了copy,因此ARC下的Block放在堆中;

    6. 为什么 NSString 使用copy修饰?

    答:

    7. 使用copy修饰可变数组 (NSMutableArray) 会造成的问题?

    答:copy修饰可变数组NSMutableArray,深拷贝,最终会变成不可变数组NSArray。
    那么原来可变数组具备的添加、删除对象的方法,都不可用。 此时生成的不可变数组再使用上述方法就会崩溃。

    8. 为什么xib或storyBoard拖线的控件使用weak,而代码创建的使用strong?

    • IBOutlet使用weak的原因
      (1) 拖线产生的对象会添加到控制器的view的subViews里,
      控制器vc 对其view肯定是强引用,view持有控件但是控制器不需要直接持有。如果控件也设置strong,存在父控件被销毁子控件仍然存在从而内存泄漏; 并且为了保证父子控件相同的生命周期,也应该使用weak;
    • 代码使用strong 的原因
      代码定义的控件如button,在使用是 self.button 即控制器直接持有button, 强引用因此使用strong 。

    9. __weak 与__block

    weak 是修饰属性, 而 __weak 和 __block 用于修饰变量。

    • 使用场景不同
      __weak 用于断开 block 容易产生的循环引用;
      __ block 则是由于内部想要修改外部的值,由原来的值传递转换成指针传递。
    展开全文
  • 一、static 关键字:代表静态的,可用于修饰 属性、方法、代码块、 **内部类 1. static 修饰的属性...2. 类变量实例变量的区别? ①内存中的位置不同 ②生命周期不同 3. static 修饰的方法(静态方法或类方法
  • Java关键词系列:final finalizefinalize ● 什么是finalize()方法 1.... final finalize 的区别 4. final ● final关键字有哪些用法 1. final 与 static 关键字可以用于哪里?它们的作用是什么 2
  • (1)public:可以被所有其他类所访问。...(4)default(默认):同一包中的类可以访问,声明时没有加修饰符,认为是friendly。  修饰符  类内部  本包  子类 外部包  public   √  √  √  √
  • 关键字 ... 自定义常量的格式:权限修饰符 static final 数据类型 变量名 = 初始化值; 当前变量:是一个常量,而且可以被类名直接访问! final:状态修饰符,最终的,无法更改的! final修饰类,该类不能继
  • transientvolatile两个关键字区别

    千次阅读 2018-01-18 09:21:34
    transienttransient是类型修饰符,只能用来修饰字段。在对象序列化的过程中,标记为transient的变量不会被序列化。示例:class Test {transient int a; // 不会被持久化int b; // 持久化}当类Test的实例对象被序列
  • 访问修饰符修饰符class 类名称 extends 父类名称 implement 接口名称(访问修饰符修饰符的位置可以互换)访问修饰符名称说明备注public可以被所有类访问(使用)public类必须定义在类名相同的同名文件中package可以...
  • 主要内容:块普通代码块构造代码块静态代码块同步代码块package、import 区别javabean权限修饰符继承概念继承的特性重写(override)super关键字 块 块一共分为四种,分别是:普通程序块、构造代码块、静态代码块、...
  • 在Java编程中,我们会经常使用修饰符public、private、protected、default去修饰变量、方法类,但是它们区别都是怎么样的呢? 访问权限控制: public:具有最大访问权限。可以被同一项目下的任何类所调用,一般...
  • 面向对象1.1 this 关键字1.2 super关键字1.3 static修饰符1.4 final修饰符1.5 代码块1.6 内部类匿名内部类1.6.1匿名内部类1.7 枚举2.总结2.1 this的作用是什么?都有哪些用途?2.2 super的作用是什么?都有哪些...
  • instanceof操作 -x instanceofA:检验x是否为类A的对象,返回值为boolean型。 -要求x所属的类与类A必须是子类父类的关系,否则编译错误 -如果x属于类A的子类B,x instanceofA值也为true。 -格式:对象a ...
  • Java基础(八) Java修饰符及接口详解之(一)static/final/abstract关键字及接口的使用 static 修饰符 final 修饰符 abstract 修饰符 接口 访问控制 == equals() 的区别 基本数据类型对应的包装类型 内部类 1. ...
  • thissuper的区别 访问成员的区别 this关键字 this特点 this使用场景 static关键字 例子 访问权限修饰符 特点 总结: 四个修饰符的特点 访问权限修饰符的宽严关系 final关键字 用法 自定义常量 final修饰...
  • 在C#的继承中尝尝会用到相关的修饰词:overridenew... new:在用作声明修饰符时,new关键字可以显式隐藏从基类继承的成员。 隐藏继承的成员时,该成员的派生版本将替换基类版本。 以上是这两个修饰符的解释。对于...
  • 关键字volatitle的主要作用是使变量在多个线程间可见。关键字volatile的作用是强制从公共堆栈中取得变量的值,而不是从线程私有数据栈中取得变量的值。 public class RunThread extends Thread { private volatile...
  • 两者的区别都是java中的关键字哦 transient 暂时的,transient 为不应被串行化的数据提供了一个语言级的标记数据方法。 是类型修饰符,只能用来修饰字段。在对象序列化的过程中,标记为transient的变量不会被序列化...
  • public 关键字是类型类型成员的访问修饰符。公共访问是允许的最高访问级别,对访问公共成员没有限制。protected 关键字是一个成员访问修饰符。受保护成员在它的类中可访问并且可由派生类访问。private 关键字是一...
  • 面向对象 面向过程的理解。类、对象 的概念、关系和区别。类对象的创建使用。类对象的存储。类中的成员 属性方法。方法的理解好处。...访问修饰符 。 封装 。this关键字。 构造器。 其他相关概念
  • final修饰符

    2018-01-30 16:54:24
    final修饰符 final成员变量 类变量的定义 实例变量的定义 final局部变量 final修饰基本类型变量引用类型变量的区别 可执行宏替换的final变量 final方法 final类 不可变类 缓存实例的不可变类 参考资料 ...
  • java基础面向对象特征:封装 继承 super,this关键字,四种访问修饰符,常用的包,重写重载,static修饰符 封装 public class Person { //特征 private String name; private int age; private String gender; ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 976
精华内容 390
关键字:

修饰符和关键字区别