精华内容
下载资源
问答
  • 主要介绍了Java synchronized关键字和Lock接口实现原理,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • java继承与关键字

    千次阅读 2019-03-03 16:51:13
    通过extends关键字可以实现类与类的继承 class 子类名 extends 父类名 {} 单独的这个类称为父类,基类或者超类;这多个类可以称为子类或者派生类。 Java只支持单继承,不支持多继承。 继承的特点: 1.一个类只能有一...

    一:继承
    通过extends关键字可以实现类与类的继承
    class 子类名 extends 父类名 {}
    单独的这个类称为父类,基类或者超类;这多个类可以称为子类或者派生类。
    Java只支持单继承,不支持多继承。
    继承的特点:
    1.一个类只能有一个父类,不可以有多个父类。
    2.Java支持多层继承(继承体系)

    二:关键字
    1.this
    this代表本类对应的引用
    访问成员变量:this.成员变量
    访问构造方法:this(…)
    访问成员方法:this.成员方法()

    2.static
    可以修饰成员变量和成员方法
    随着类的加载而加载
    优先于对象存在
    被类的所有对象共享
    可以通过类名调用

    3.super
    super代表父类存储空间的标识
    访问成员变量:super.成员变量
    访问构造方法:super(…)
    访问成员方法:super.成员方法()

    4.final
    final关键字是最终的意思,可以修饰类,成员变量,成员方法。
    修饰类,类不能被继承
    修饰变量,变量就变成了常量,只能被赋值一次
    修饰方法,方法不能被重写
    在这里插入图片描述在这里插入图片描述在这里插入图片描述在这里插入图片描述

    展开全文
  • 接口interface关键字的基础语法 1.接口也是一种引用数据类型。编译之后也是一个class字节码文件。 2.接口是完全抽象的。抽象类是半抽象的,或者也可以说接口是一种特殊的抽象类。 3.接口怎么定义? [修饰符列表] ...

    接口interface关键字的基础语法:

    1、接口也是一种引用数据类型,编译之后也是一个class字节码文件

    2、接口是完全抽象的,抽象类是半抽象的,或者也可以说接口是一种特殊的抽象类。

    3、接口怎么定义?
    [修饰符列表] interface 接口名{ }

    4、接口中所有的元素都是用public修饰的,都是公开的。

    5、接口中只有两部分内容:
    常量(public final static修饰的变量)
    抽象方法(public abstract修饰的方法)

    附提:java8新特性,让接口内容更多。

    6、接口中的方法都是抽象方法,抽象方法不能有方法体。

    7、接口中的常量都是public final static修饰的,抽象方法都是public abstract修饰的,修饰符可以省略不写

    8、接口支持多继承,一个接口可以继承多个接口。

    9、类与类之间叫做继承,接口与接口之间也叫继承,那么类与接口之间叫什么关系?

    答:我们称类与接口的关系为”实现“,接口不能实现类,只能类去实现接口,一个类可以实现多个接口。这种机制弥补了java中类只能单继承的缺陷


    如何理解类“实现”接口?
    答:我们先把接口理解为一种特殊的抽象类,类“实现”多个接口,相当于这个类 “特殊的继承(实现)” 了多个 “特殊的抽象类(接口)”。

    继承使用extends关键字,实现使用implements关键字。


    10、非抽象类继承抽象类,必须重写父类的所有抽象方法。
    非抽象类实现接口,必须实现接口的所有抽象方法

    所以抽象类实现接口,可以实现接口的抽象方法,也可以不实现。因为抽象方法可以在出现抽象类里面,实际上抽象方法就是只能在抽象类中。

    如果抽象类实现了接口的抽象方法,则抽象类的子类无需再重写。没实现的抽象方法,抽象类的子类一定得重写,不重写会报错。

    测试代码:

    public class Test {
        public static void main(String[] args) {
            //访问接口的常量,接口可以理解为一种特殊的抽象类,直接使用“接口名.”访问
            System.out.println("π = " + MyMath.PI);
            System.out.println("e = " + MyMath.E);
    
            //把接口理解成一种特殊的抽象类,那可以使用多态吗?可以,并且以后开发就是这么写代码的。
            //多态:父类型引用指向子类型对象,鹦鹉算数
            MyMath m1 = new Parrot();
            int res1 = m1.add(10, 20);
            int res2 = m1.sub(10, 20);
            System.out.println("a = " + res1 + ", b = " + res2);
    
            //多态:人算数
            MyMath m2 = new Person();
            int res3 = m2.add(10, 20);
            int res4 = m2.sub(10, 20);
            System.out.println("a = " + res3 + ", b = " + res4);
        }
    }
    
    //定义一个接口M1
    interface M1 {
    
    }
    
    //定义一个接口M2
    interface M2 {
    
    }
    
    //定义一个MyMath接口
    interface MyMath extends M1, M2 {
        //常量:圆周率PI
        public final static double PI = 3.1415926;
    
        //常量:自然对数的底数E
        double E = 2.718281828;  //接口中常量的public final static可以省略
    
        //抽象方法:加add
        public abstract int add(int a, int b);
    
        //抽象方法:减sub
        int sub(int a, int b);  //接口中抽象方法的public abstract可以省略
    }
    
    //定义一个人的类,实现M1,M2,MyMath接口
    class Person implements M1, M2, MyMath{
        @Override
        public int add(int a, int b) {
            return a + b;
        }
    
        @Override
        public int sub(int a, int b) {
            return a - b;
        }
    }
    
    //定义一个抽象鸟类,实现MyMath接口
    abstract class Bird implements MyMath{
        //抽象类Bird实现了MyMath的sub方法,Bird的子类不需要再重写
        public int sub(int a, int b) {
            return a - b;
        }
    
        //抽象类Bird没有实现MyMath的add方法,就必须留给Bird的子类实现。
        //抽象类中没实现接口的方法相当于继承过来了
        public abstract int add(int a, int b);
    }
    
    //定义一个鹦鹉类,继承抽象类Bird
    class Parrot extends Bird {
    
        public int add(int a, int b) {  //重写父类的抽象方法
            return a + b;
        }
    
    }
    

    接口看成一种特殊的抽象类,故也存在多态语法:

    测试代码

    public class Test02 {
        public static void main(String[] args) {
            /*D d = new D();
            d.m1();  //输出:m1()方法实现
            d.m2();  //输出:m2()方法实现*/
    
            //运用多态:父类型的引用指向子类型的对象
            //先测试一下接口与接口之间的转换关系
            A a = new D();
            B b = (B)a;  //此行编译通过,所以得出结论,java编译中允许没有继承关系的两个接口之间强制转换。
            //为什么?答:因为在编译时不实例化对象,编译器不知道a1指向的是什么类对象,万一这个类实现了这两个接口,这两个接口之间就可以强制转换,所有编译器认定所有两个接口之间都能强制转换。
            //C c = (C)a;  //此行编译通过,但运行时报错:ClassCastException: class D cannot be cast to class C (D and C are in unnamed module of loader 'app')
            //虽然java中允许没有继承关系的两个接口之间强制转换,但运行时可能出现ClassCastException,为防止这种情况,建议使用instanceof判断
            //上面两行转型代码应该这样写
            if (a instanceof B) {
    
            }
            if (a instanceof C) {
    
            }
    
            //现在我们再来测试接口的多态
            //D类实现了2个接口A,B,相当于父类型有2个,那怎么用多态?
            //第一种:A类型接口指向D类型引用
            A a1 = new D();
            //a1.m1();  //输出:m1()方法实现
            //a1.m2();  //编译报错:a1里找不到m2()方法,如果a1想调用a2方法,可以转换接口或者向下转型成D,下面再讲
            //第二种:B类型接口指向D类型引用
            //B b1 = new D();
            //b1.m2();  //输出:m2()方法实现
    
            //通过向下转型:接口A a1 --> D类型,向下转型用instanceof关键字先判断
            if (a1 instanceof D) {  //条件为true,因为a1指向的堆对象是D类型
                D d1 = (D) a1;
                //d1.m1();  //输出:m1()方法实现
                //d1.m2();  //输出:m2()方法实现
            }
    
            //接口A a1 --> B接口型
            if (a1 instanceof B) {  //条件为true,因为a1指向的堆对象是D类型,D类型实现(继承)了B接口,D属于B,条件成立
                B b1 = (B)a1;
                b1.m2();  //输出:m2()方法实现
            }
            //试一下A a1接口能不能 --> C接口
            if (a1 instanceof C) {  //条件不成立,因为a1指向的堆对象是D类型,D类型没有实现(继承)B接口,D不属于B,条件不成立
                C c1 = (C)a1;
                c1.m3();  //条件不成立,里面代码不执行,没输出
            }
    
        }
    }
    
    //接口A
    interface A {
        void m1();
    }
    
    //接口B
    interface B {
        void m2();
    }
    
    //接口C
    interface C {
        void m3();
    }
    
    //类D,实现了接口A,B
    class D implements A, B{
        @Override
        public void m1() {
            System.out.println("m1()方法实现");
        }
    
        @Override
        public void m2() {
            System.out.println("m2()方法实现");
        }
    
    }
    

    不同的类实现同一接口会有不同的作用:

    测试代码:

    /*
    * 继承和实现都存在的话,代码应该怎么写
    *   extends关键字在前,implements关键字在后,例如:class B extends A implements C1, C2 { }
    *
    * */
    public class Test03 {
        public static void main(String[] args) {
            Wings w1 = new Duck();
            w1.fly();
    
            Wings w2 = new Cat();
            w2.fly();
        }
    }
    
    //定义一个接口:Wings(翅膀)
    interface Wings {
        void fly();
    }
    
    //定义一个类:Animal(动物)
    class Animal {
    
    }
    
    //定义一个子类:Duck(鸭子)
    class Duck extends Animal implements Wings {
        @Override
        public void fly() {
            System.out.println("有了翅膀接口,我就是一只会飞的鸭子!");
        }
    }
    
    //定义一个子类:Cat(猫)
    class Cat extends Animal implements Wings {
        @Override
        public void fly() {
            System.out.println("有了翅膀接口,我就是一只会飞的猫!");
        }
    }
    

    ————————————————————————————
    总结:

    1、接口是一种引用数据类型,编译之后也产生“.class”文件。

    2、接口是完全抽象的,抽象类是半抽象的。

    3、接口怎么定义:[访问修饰符] interface 接口名 { }

    4、接口支持多继承,一个接口可以继承多个接口。

    5、接口中的元素都是公开的,都是public修饰的。

    6、接口中只有常量(public final static修饰)和抽象方法(public abstract)。

    7、接口中常量的public final static,抽象方法的public abstract修饰符都可省略不写

    8、接口中的抽象方法不能有方法体

    9、一个非抽象类实现接口时,必须将接口中所有抽象方法重写

    10、一个类可以同时实现多个接口。

    11、一个类继承父类,同时实现接口时,extends在前,implements在后

    12、接口也存在多态的使用:父类型的接口引用变量指向子类型对象。

    展开全文
  • Java50个关键字总结

    万次阅读 多人点赞 2018-09-15 15:40:44
    作业一:Java基础知识复习 一、关键字总结 1.abstract 修饰类: abstract修饰类,这个类就是抽象类,抽象类中可以有非抽象变量和成员变量,也可以有普通方法、构造方法。但是不能...

    作业一:Java基础知识复习

    一、关键字总结

    1.abstract

    • 修饰类:

    abstract修饰类,这个类就是抽象类,抽象类中可以有非抽象变量和成员变量,也可以有普通方法、构造方法。但是不能实例化,只能被子类继承。
    如果子类不是抽象类,则必须重写父类的抽象方法。

    public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
        ...
    }
    
    • 修饰方法:

    abstract修饰方法,这个方法就是抽象方法。抽象方法必须存在于抽象类中。抽象方法不能有具体实现。

    abstract public E get(int index);
    

    2.assert

    assert表示“断言”,有两种使用方法:

    assert 表达式;
    

    若表达式为真,程序继续执行;若表达式为假,则抛出一个AssertionError异常。

    assert 表达式:错误信息;
    

    与第一种方法相同,只是异常中带有错误信息。
    使用assert时不能在表达式中完成任何程序实际所需的行为(只能做判断)。因为正常发布的代码都是断言无效的,即正常发布的代码中断言语句都不不执行的。

    3.boolean

    boolean是Java的基本类型之一(默认值false)。只有两个值:true和false。区别C的判断句,Java不能直接使用1和0来表示真假,且boolean类型也不能强转到其他基本类型。

    boolean a = true;
    boolean b = false;
    

    4.break

    1. break在switch中用于跳出switch块,停止switch向下穿透的现象。
    case value:expression;
        break;
    
    1. break在循环中用于跳出循环。
    while(...){
        ...
        break;
    }
    
    1. break也可以在后面接标签,用来跳出一些嵌套比较复杂的循环中。
    flag:
    for(...){
        for(...){
            break flag;
        }
    }
    

    5.byte

    byte是Java的基本类型之一(默认值0)。表示8位有符号整数。

    范围:-128~127

    byte a = 100;
    

    6.case

    case用于switch中,用于判断和执行语句。用法:

    case 变量值:语句;
    

    若变量值和switch(变量值)
    中的变量值相等,就执行后面的语句。执行完后继续执行下一个case语句。

    7.catch

    catch用于捕获异常。
    用法:

    catch(异常类型 异常){...}
    

    在try/catch语句块中,catch捕获发生的异常,并应对错误做一些处理。
    当catch捕获到异常后,try中执行的语句终止,并跳到catch后的语句中。

    8.char

    char是Java的基本类型之一(默认值\u000)。表示16位、在Unicode编码表中的字符。使用单引号来表示字符常量,例如’A’。

    范围:0-65535

    char a = 'A';
    

    9.class

    class表示类。用于声明一个类。

    [访问控制] (abstract) class 类名 (implements){...}
    

    10.const

    const是Java的一个保留关键字,没有实际意义,但是不能用于做变量名(因为被保留作为关键字了)。在C语言中表示常量,类似Java的final。

    11.continue

    1. continue用于在循环中跳过本次循环。
    while(...){
        ...
        continue;
    }
    
    1. continue也可以在后面接标签,在一些嵌套比较复杂的循环中跳过一次循环。
    flag:
    for(...){
        for(...){
            continue flag;
        }
    }
    

    12.default

    default关键字:

    1. 用于switch做默认分支:
    default:语句;
    
    1. 用于接口,让接口实现具体的方法:
    public interface a{
        default void b(){
            具体方法;
        }
    }
    

    default用于接口时,必须要有具体实现。
    (API>=24)

    13. do

    do用于和while组成循环,do/while循环不同于while循环,属于先执行循环体再判断。

    do{
    	循环体;
    }while(...)
    

    14.double

    double是Java的基本类型之一(默认值0.0d),表示双精度、64位的浮点数。

    double a = 0.1d;
    

    15.else

    else用于分支结构中的判断。例如:

    if(判断1){
        语句1;
    }else if(判断2){
        语句2;
    }else{
        语句3;
    }
    

    16.enum

    enum表示枚举,用于限制变量值的类型,例如:

    public enum Alpha (implements 接口){
        (public static final)a,b,c,d
    }
    

    规定Color的实例只能为a,b,c,d其中之一。

    枚举类中可以有成员变量和方法。

    17.extends

    extends表示继承。例如:

    class 子类 extends父类{}
    

    Java中的继承是单继承,即子类只能有一个直接父类。
    除了private,子类可以访问父类的方法和成员变量。

    18.final

    1. 修饰变量:
      将变量变为常量,在初始化变量后不能再改变值。
    2. 修饰方法:
      被final修饰的方法不能被子类重写。
    3. 修饰类:
      被final修饰的类不能被继承。

    19.finally

    finally在try/catch语句块中处理一些后续的工作。例如关闭网络连接和输入输出流等。

    • 如果在try/catch中使用return,则finally会撤销这个return,无论如何都会执行finally中的语句。

    20.float

    float是Java的基本类型之一(默认值0.0f)。表示单精度、32位的浮点数。

    float a = 0.1f;
    

    21.for

    for用于循环:

    for(初始化循环变量; 判断执行条件;更新循环变量){
        语句
    }
    for(变量:数组){
        语句
    }
    

    22.goto

    Java中的保留关键字,没有实际意义,但是不能用做变量名。在C中表示无条件跳转语句。

    23.if

    if用于分支结构中的判断。常与else和else if使用。

    if(表达式){语句}
    

    若表达式为真,则执行后面的语句。

    24.implements

    implements用于接入接口。接上接口的类必须实现接口的抽象方法(可以不实现默认方法和静态方法)。

    class A implements B{
        @Override
        do(){
            ...
        }
    }
    

    25.import

    用于导入包。

    import android.content.Intent;
    

    26.instanceof

    instanceof用于判断类与对象的关系。例如:

    a instanceof b
    

    若a是b的一个实例(或子类对象),则整个表达式的结果是true,否则结果为false。

    27.int

    int是Java的基本类型之一(默认值为0)。表示32位、有符号的整数。

    范围:[-231,231-1)

    int a = 1;
    

    28.interface

    interface用于声明一个接口,例如:

    public interface A{
        void b();
    }
    

    声明a为一个接口,若接上该接口,则必须实现其中的抽象方法b。
    接口中的成员变量是static、final、public的。接口中的方法为静态方法或默认方法和静态方法(API>=24)。

    29.long

    long是Java的基本类型之一(默认值为0L),表示64位、有符号的整数。

    范围:[-263,263)

    long a = 3216846849646L;
    

    30.native

    native可以让Java运行非Java实现的方法。例如c语言,要编译后用javah产生一个.h文件。导入该.h文件并且实现native方法,编译成动态链接库文件。在Java加载动态链接库文件,这个native方法就可以在Java中使用了。

    public native void aVoid();
    

    31.new

    new用于生成类的实例。

    Object a = new Object()

    32.package

    package用于规定当前文件的包。

    package com.example.zhangyijun.testdefactivity;
    

    33.private

    访问控制的一种。
    私有的方法和变量只能在本类中访问。类和接口不能为私有。

    private int a = 1;
    private void b(){
        ...
    }
    

    34.protected

    访问控制的一种。
    受保护的方法和变量只能给子类和基类访问。

    protected int a = 1;
    protected void b(){
        ...
    }
    

    35.public

    访问控制的一种。
    公有的方法、类、变量、接口能够被任何其他类访问。

    36.return

    方法中返回数据,并结束方法。

    37.strictfp

    使用strictfp关键字来声明一个类、接口或者方法时,那么该类、接口或者方法会遵循IEEE-754标准来执行,提高浮点运算的精度,并且减少不同硬件平台之间由于浮点运算带来的差异。

    public strictfp double aDouble(){
        return 0d;
    }
    

    38.short

    short是Java的基本类型之一(默认值0),表示16位、有符号的整数。

    范围:[-215,215)

    short a = 0;
    

    39.static

    static修饰的语句块存放在堆的方法区中。

    1. 静态变量:依附在类中的变量,可以被类的所有的实例共用。
    static int a = 0;
    
    1. 静态方法:依附在类中的方法。静态方法只能访问类中的静态变量和静态方法。
    publlic static void b(){
        ...
    }
    
    
    1. 静态块:在类加载的时候执行块中的语句,块中不能访问非静态变量。
    static{
        ...
    }
    
    1. 静态内部类:用static修饰内部类。

    40.super

    super即超类

    1. 引用父类的的成员:
    super.xxx
    
    1. 变量或方法重名时用super调用父类的成员或方法。
    2. 调用父类的构造方法:
    super(xxx);
    

    41.switch

    switch用于分支结构,判断某个变量与一系列值是否相等。switch 语句中的变量类型可以是: byte、short、int 、char、String、enum。

    switch(变量){
    	case value1:语句1;
    		break;
    	case value2:语句2;
    		break;
    	...
    	default:语句;
    }
    
    1. 若变量和case后的值相等则执行语句。
    2. 当语句执行到break时跳到switch块后,如果没有break会产生穿透现象。
    3. default分支必须为最后一个分支,在没有值和case变量相等时执行该语句。

    42.synchronized

    synchronized关键字用于保证线程安全。由这个关键字修饰的方法或者代码块保证了同一时刻只有一个线程执行该代码。

    synchronized(obj){...}
    

    当一个线程访问同步代码块时,检查obj是否有锁,如果有就挂起。如果没有就获得这个obj的锁,也就是把其他线程锁在了外面。当代码执行完毕时释放该锁,其他线程获得锁继续执行代码。

    43.this

    1. 指向当前对象:this.xxx
    2. 形参和成员名字重名时时用this区分。
    3. 引用构造函数。

    44.throw

    用于抛出一个异常。

    throw (Exception);
    

    45.throws

    在方法中将发生的异常抛出。

    [控制访问](返回类型)(方法名)([参数列表])[throws(异常类)]{...}
    

    46.transient

    类接上序列化接口后,可以通过transient关键字将某些变量变得无法序列化。

    transient int a = 1;
    

    47.try

    在try/catch中,将可能出现异常的语句放在try{}块中,出现异常之后代码将会终止并跳到catch中继续执行。

    try{
        ...
    }catch(Exception e){
        ...
    }finally{
        ...
    }
    

    48.void

    修饰方法,表示方法没有返回值。

    49.volatile

    volatile关键字修饰的变量在多线程中保持同步。相比synchronized效率要高,不会阻塞线程。但只能保证数据的可见性,不能保证数据的原子性。例如在处理i++的时候另外一个线程修改i的值,那么i的值将会发生错误,这是原子性导致的。

    volatile int a;
    

    50.while

    while用于两种循环结构:

    while(判读语句){
        循环体...
    }
    
    do{
    	循环体...
    }while(判读语句)
    

    二、查漏补缺

    1.多态

    多态就是同一个行为,使用不同的实例而发生不同的作用。在使用多态调用方法的时候,编译器检查父类中是否有该方法,如果有才能编译通过,例如:

    public class Animals{
        void voice(){动物叫}
    }
    
    class Cat extends Animals{
        void voice(){猫叫}
    }
    
    public static void testVoice(Animals a){
        a.voice();
    }
    
    public static void main(String[] args) {
        testVoice(new Cat());
    
        Animals a = new Cat();
        a.voice();
    }
    

    猫继承自动物这个类,Animals a = new Cat()是向上转型(父类引用指向子类对象),实际的运行时类型还是Cat,也就是说a instanceof Cat 表达式为真,因此调用a的voice()方法是猫叫。结合C的指针和内存分析来理解多态。

    2.泛型

    1. 类型通配符
    • <? extends T>表示该通配符所代表的类型是T类型的子类。
    • <? super T>表示该通配符所代表的类型是T类型的父类
    public static <T extends Closable> void close(T... a){
        for(T temp:a){
            try{
                if(temp!=null){
                    temp.close();
                }
            }catch(IOException e){
                e.printStackTrace();
            }
        }
    }
    
    1. 泛型不能用在静态属性上
    2. 指定的类型不能为基本类型

    3.反射

    1. 获取目标类型的Class对象
    Class<?> a = Object.getClass();
    Class<?> b = T.class;
    Class<?> c = Class.forName(...);
    
    1. 通过 Class 对象分别获取Constructor类对象、Method类对象 & Field 类对象

      • 不带 "Declared"的方法支持取出包括继承、公有(Public) & 不包括有(Private)的构造函数
      • 带 "Declared"的方法是支持取出包括公共(Public)、保护(Protected)、默认(包)访问和私有(Private)的构造方法,但不包括继承的构造函数
    • Constructor
    //a.获取指定的构造函数(公共/继承)
    Constructor<T> getConstructor(Class<?>... parameterTypes);
    //b.获取所有的构造函数(公共/继承) 
    Constructor<?>[] getConstructors(); 
    //c.获取指定的构造函数(不包括继承)
    Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes);
    //d.获取所有的构造函(不包括继承)
    Constructor<?>[] getDeclaredConstructors(); 
    
    • Field
    //a.获取指定的属性(公共/继承)
    Field getField(String name);
    //b.获取所有的属性(公共/继承)
    Field[] getFields();
    //c.获取指定的所有属性(不包括继承)
    Field getDeclaredField(String name);
    //d.获取所有的所有属性(不包括继承)
    Field[] getDeclaredFields();
    
    • Method
    //a.获取指定的方法(公共/继承)
    Method getMethod(String name, Class<?>... parameterTypes);
    //b.获取所有的方法(公共/继承)
    Method[] getMethods();
    //c.获取指定的方法 (不包括继承)
    Method getDeclaredMethod(String name, Class<?>... parameterTypes);
    //d.获取所有的方法(不包括继承)
    Method[] getDeclaredMethods();
    

    4. 集合

    1. 迭代器遍历ArrayList
    Iterator<String> iterator = list.iterator();
    while(ite.hasNext()){
        Log.d("TAG",ite.next());
    }
    
    
    1. 遍历Map
    //第一种:map.keySet()
    for (String key : map.keySet()) {
        System.out.println("key= "+ key + " value= " + map.get(key));
    }
    
    //第二种:map.entrySet().iterator()
    Iterator<Map.Entry<String, String>> iterator = map.entrySet().iterator();
    while (it.hasNext()) {
        Map.Entry<String, String> entry = it.next();
        System.out.println("key= " + entry.getKey() + " value= " + entry.getValue());
    }
          
    //第三种:map.entrySet()
    for (Map.Entry<String, String> entry : map.entrySet()){
        System.out.println("key= " + entry.getKey() + " value= " + entry.getValue());
    }
        
    //第四种:map.values()
    for (String v : map.values()) {
        System.out.println("value= " + v);
    }
    
    1. 遍历 hashMap() 时 entrySet() 方法是将 key 和 value 全部取出来,所以性能开销是可以预计的, 而 keySet() 方法进行遍历的时候是根据取出的 key 值去查询对应的 value 值, 所以如果 key 值是比较简单的结构(如 1,2,3…)的话性能消耗上是比 entrySet() 方法低, 但随着 key 值得复杂度提高 entrySet() 的优势就会显露出来。
    2. 在只遍历 key 的时候使用 keySet(), 在只遍历 value 的时候使用 values(), 在遍历 key-value 的时候使用 entrySet()。

    5.正则

    RegexBuddy

    1. 转义字符
    \n  \t  \\  \^  \$  \(  \)  \{  
    \}  \?  \+  \*  \|  \[  \]
    
    1. 标准字符集合(大写取反)
    \d0~9的任意一个数字
    \wA~Z, a~z, 0~9, _中任意一个
    \s空格、制表符、换行符等空白符的任意一个
    .匹配任意一个字符
    []匹配方括号中任意一个字符
    ^方括号取反
    -方括号中表示范围
    {}花括号前正则表达式的重复次数,{m,n}至少m次,最多n次
    ?花括号后加,非贪婪模式。非花括号后加,相当于{0,1}
    +前面的正则表达式至少出现一次,相当于{1,}
    *表达式不出现或出现多次,相当于{0,}
    ^与字符串开始的地方匹配
    $与字符串结束的地方匹配
    \b匹配一个字符边界
    |匹配左边或者右边
    (?=exp)断言自身出现的位置的后面能匹配表达式exp
    (?<=exp)断言自身出现的位置的前面能匹配表达式exp
    (?!exp)断言此位置的后面不能匹配表达式exp
    (?<!exp)断言此位置的前面不能匹配表达式exp

    6.引用分类

    1. 强引用:StrongReference:引用指向对象,gc运行时不回收
    2. 软引用:SoftReference:gc运行时回收,(jvm内存不够)
    3. 弱引用:WeakReference:gc运行时立即回收
    4. 虚引用:PhantomReference:跟踪对象被回收的状态,必须与ReferenceQueue一起使用
    展开全文
  • 增加default方法:又叫做接口扩展方法,即在不破坏java现有实现架构的情况下能往接口里增加新方法, default关键字可以给接口添加一个非抽象的方法实现,子类可以直接调用! 如果想对接口增加一个新方法,那么需要对...
  • Java中的关键字有哪些?Java关键字(keyword)有多少个?Java的保留字(reserveword)有多少个?分别是什么?Java关键字分别是什么,作用是什么?

    Java中的关键字有哪些?

    1)48个关键字:abstract、assert、boolean、break、byte、case、catch、char、class、continue、default、do、double、else、enum、extends、final、finally、float、for、if、implements、import、int、interface、instanceof、long、native、new、package、private、protected、public、return、short、static、strictfp、super、switch、synchronized、this、throw、throws、transient、try、void、volatile、while。

     

    2)2个保留字(现在没用以后可能用到作为关键字):goto、const。

     

    3)3个特殊直接量:true、false、null。 

     

    1.Java的关键字(keyword)有多少个?

       51+2个保留字=53个关键字(java的关键字都是小写的!!)

     

    2.Java的保留字(reserve word)有多少个?分别是什么?

         2个保留字

         Java语言的的保留字是指预留的关键字

       1).const  有道释义:n. 常量,常数  

                用于修改字段或局部变量的声明。它指定字段或局部变量的值是常数,不能被修改

       2).goto   有道释义:vi. 转到

             指定跳转到标签,找到标签后,程序将处理从下一行开始的命令。

     

    3.Java的关键字分别是什么,作用是什么?

       1).访问修饰符的关键字(共3个)

    关键字

    意思

    备注,常用

    public

     公有的

    可跨包,(默认选择)

    protected 

     受保护的

    当前包内可用

     

    private

    私有的

    当前类可用

     

        2).定义类、接口、抽象类和实现接口、继承类的关键字、实例化对象(共6个)

    关键字

    意思

    备注,常用

    class

    public class A(){}  花括号里有已实现方法体,类名需要与文件名相同

    interface

     

    接口

    public interface B(){}  花括号里有方法体,但没有实现,方法体句子后面是英文分号“:”结尾

    abstract

     

    声明抽象

    public abstract class C(){} 介于类与接口中间,可以有也可以没有已经实现的方法体

    implements

     

    实现

    用于类或接口实现接口public class A  interface B(){}

    extends

     

    继承

    用于类继承类 public class A extends D(){}

    new

    创建新对象

    A a=new A();  A表示一个类

       

       3).包的关键字(共2个)

    关键字

    意思

    备注,常用

    import

    引入包的关键字

    当使用某个包的一些类时,仅需类名 然后使用ctrl+shift+o或者选定类名(类或属性或方法)按住ctrl+单击 即可自动插入类所在的包。如:JFrame 快捷键之后自动加入

    import javax.swing.JFrame;

    package

    定义包的关键字

    将所有有关的类放在一个包类以便查找修改等。如:package javake.flycat.draw002;

      

       4).数据类型的关键字(共12个)

    关键字

    意思

    备注,常用

    byte

    字节型

    8bit

    char

    字符型

    16bit

    boolean

    布尔型

    --

    short

    短整型

    16bit

    int 

    整型

    32bit

    float

    浮点型

    32bit

    long

    长整型

    64bit

    double

    双精度

    64bit

    void

    无返回

    public void A(){}   其他需要返回的经常与return连用

    null

    空值

     

    true

     

    false

     

       

       5).条件循环(流程控制)(共12个)

    关键字

    意思

    备注,常用

    if

    如果

    if(){} 如果小括号里面怎么怎么样 花括号就怎么怎么样

    else

    否则,或者

    常与if连用,用法相同

    while

    当什么的时候

    while 怎么样就do什么    while(){}

    for

    满足三个条件时

    for ( ; ; ){}

    switch

    开关

    switch(表达式)
    {
    case 常量表达式1:语句1;
    ....
    case 常量表达式2:语句2;
    default:语句;
    }
    default就是如果没有符合的case就执行它,default并不是必须的.
    case后的语句可以不用大括号.
    switch语句的判断条件可以接受int,byte,char,short,不能接受其他类型.

    case

    返回开关里的结果

    default

    默认

    do

    运行

    长与while连用

    break

    跳出循环

     

    continue

    继续

    中断本次循环,并并开始下一次

    return

    返回

    return 一个返回值类型

    instanceof

    实例

    一个二元操作符,和==,>,<是同一类的。测试它左边的对象是否是它右边的类的实例,返回boolean类型的数据

      

       6).修饰方法、类、属性和变量(共9个)

    关键字

    意思

    备注,常用

    static

    静态的

    属性和方法都可以用static修饰,直接使用类名.属性和方法名。  只有内部类可以使用static关键字修饰,调用直接使用类名.内部类类名进行调用。   static可以独立存在。静态块

    final

    最终的不可被改变的

    方法和类都可以用final来修饰    

    final修饰的类是不能被继承的    

    final修饰的方法是不能被子类重写。

    常量的定义:

    final修饰的属性就是常量。

    super

    调用父类的方法

    常见public void paint(Graphics g){

    super.paint(g); ··· }

    this

    当前类的父类的对象

    调用当前类中的方法(表示调用这个方法的对象)

    this.addActionListener(al):等等

    native

    本地

     

    strictfp

    严格,精准

     

    synchronized

    线程,同步

     

    transient

    短暂

     

    volatile

    易失

     

      static 例子:

    public class Test{
    
        class A{}   //内部类
    
        ActionListener al=new ActionListener(···){}   //匿名内部类
    
    }

       静态块优先于其他方法/类的执行

     

        7).错误处理(共5个)

    关键字

    意思

    备注,常用

    catch

    处理异常

    1.try+catch
    程序的流程是:运行到try块中,如果有异常抛出,则转到catch块去处理。然后执行catch块后面的语句

    2.try+catch+finally
    程序的流程是:运行到try块中,如果有异常抛出,则转到catch块,catch块执行完毕后,执行finally块的代码,再执行finally块后面的代码。
    如果没有异常抛出,执行完try块,也要去执行finally块的代码。然后执行finally块后面的语句

    3.try+finally
    程序的流程是:运行到try块中,如果有异常抛出的话,程序转向执行finally块的代码。那末finally块后面的代码还会被执行吗?不会!因为你没有处理异常,所以遇到异常后,执行完finally后,方法就已抛出异常的方式退出了。
    这种方式中要注意的是,由于你没有捕获异常,所以要在方法后面声明抛出异常

    (来自网上的资料)

    try

    捕获异常

    finally

    有没有异常都执行

    throw

    抛出一个异常对象

    一些可以导致程序出问题的因素,比如书写错误,逻辑错误或者是api的应用错误等等. 为了防止程序的崩溃就要预先检测这些因素,所以java 使用了异常这个机制.

    在java中异常是靠 "抛出" 也就是英语的"throw" 来使用的,意思是如果发现到什么异常的时候就把错误信息 "抛出"

     

    throws

    声明一个异常可能被抛出

    把异常交给他的上级管理,自己不进行异常处理

       throw是你执行的动作。比如你觉得可能有异常,那么就抱出去 如:

               String a; if(a == null),

                throw new exception("a为null");

               所以throw是一个抛出去的动作

       throws只用在一个方法的末端,表示这个方法体内部如果有异常,这抛给它的调用者。 如: public void add(int a, int b) throws Exception(); 这个方法表示,在执行这个方法的时候,可能产生一个异常,如果产生异常了,那么谁调用了这个方法,就抛给谁。(来自百度)

     

       8).不知道是什么(共2个)

    关键字

    意思

    备注,常用

    enum

    枚举,列举型别

     

    assert

    断言

     

     

     Enum:代表一组常用常量,可用来代表一类相同类型的常量值如:

    性别:

    public enum SexEnum {
    
        male, female;
    
    }

    颜色:

    public enum Color {
    
      RED, BLUE,GREEN,BLACK;
    
    }

    枚举对象里面的值都必须是唯一的。

     

    附:throw 和throws的差别

    区别一:

     

                 throw 是语句抛出一个异常;throws 是方法抛出一个异常;

     

                  throw语法:throw <异常对象>

     

                  在方法声明中,添加throws子句表示该方法将抛出异常。

     

                 throws语法:[<修饰符>]<返回值类型><方法名>([<参数列表>])[throws<异常类>]

     

                 其中:异常类可以声明多个,用逗号分割。

     

    区别二:

     

              throws可以单独使用,但throw不能;

     

    区别三:

     

                throw要么和try-catch-finally语句配套使用,要么与throws配套使用。但throws可以单独使用,然后再由处理异常的方法捕获。

     

    throws E1,E2,E3 只是告诉程序这个方法可能会抛出这些个异常,方法的调用者可能要处理这些异常。而这些异常E1,E2,E3可能是该函数体产生的。

     

    而throw是明确之处这个地方要抛出这个异常。

    void doA() throws Exception1, Exception3 {
    
      try {
    
        ……
    
      } catch(Exception1 e) {
    
        throw e;
    
      } catch(Exception2 e) {
    
        System.out.println("出错了");
    
      }
    
      if (a != b)
    
        throw new Exception3("自定义异常");
    
    }

     

    代码块……中可能产生异常Exception1、Exception2和Exception3。

    如果产生Exception1异常,则捕捉了之后抛出由该方法的调用者去做处理;

    如果产生Exception2异常,则该方法自己做了处理(打印出了说出错了),所以该方法就不会再向外抛出Exception2异常了,void doA() throws Exception1,,Excpetion3里面的Exception2也就不用写了;

    而Exception3异常是该方法的某段逻辑出错,程序员自己作了处理在该段逻辑错误的情况下抛出异常Exception3,则调用者也需要处理。

     

    throw语句用在方法体内,表示抛出异常,由方法体内的语句处理 

    throws语句用在方法声明后面,表示再抛出异常,由调用这个方法的上一级方法中的语句来处理

     

    throws主要是声明这个方法会抛出这种类型的异常,使其他地方调用它时知道要捕获这个异常。

    throw是具体向外抛异常的动作,所以它是抛出一个异常实例。

     

    throws说明你有哪个可能,倾向 

    throw的话,那就是你把那个倾向变成真实的了

    同时:

    1)throws出现在方法函数头;而throw出现在函数体; 

    2)throws表示出现异常的一种可能性,并不一定会发生这些异常;throw则是抛出了异常,执行throw则一定抛出了某种异常; 

    3)两者都是消极处理异常的方式(这里的消极并不是说这种方式不好),只是抛出或者可能抛出异常,但是不会由函数去处理异常,真正的处理异常由函数的上层调用处理。

     

    展开全文
  • java中50个关键字以及各自用法大全

    千次阅读 多人点赞 2019-11-10 17:50:38
    关键字和保留字的区别 正确识别java语言的...保留字是为java预留的关键字,他们虽然现在没有作为关键字,但在以后的升级版本中有可能作为关键字。 识别java语言的关键字,不要和其他语言如c/c++的关键字混淆...
  • Java语言的关键字

    千次阅读 2019-05-18 15:43:56
    关键字 含义 abstract 表明类或者成员方法具有抽象属性 assert 断言,用来进行程序调试 boolean 基本数据类型之一,布尔类型 break 提前跳出一个块 byte 基本数据类型之一,字节类型 ...
  • 使得在接口中可以包含方法体,这打破了Java之前版本对接口的语法限制,从而使得接口在进行扩展的时候,不会破坏与接口相关的实现类代码。 Default好处 原先接口的缺陷是,修改接口后,则需要修改全部实现接口的类...
  • Java接口——static关键字

    千次阅读 2018-12-20 09:32:31
    虽然Java语言中没有全局的概念,但可以通过static关键字来达到全局的效果。 static修饰的变量叫静态变量,静态变量属于类,在内存中只有一个复制(所有对象实例的该变量都指向同一个内存地址),只要静态变量所在的...
  • java中的关键字以及用法

    千次阅读 2018-08-12 22:01:32
    java关键字 Java关键字是电脑语言里事先定义的,有特别意义的标识符,有时又叫保留字,还有特别意义的变量。Java关键字Java的编译器有特殊的意义,他们用来表示一种数据类型,或者表示程序的结构等,关键字不能...
  • 零基础自学java,点击了解:https://how2j.cn/p/5340关键字 关键字属于保留字,在 Java 中具有特殊的含义,比如说 public、final、static、new 等等,它们不能用来作为变量名。为了便于你作为参照,我列举了 48 个常用...
  • Java标识符和关键字

    千次阅读 多人点赞 2019-04-17 14:49:39
    Java标识符定义 ...3、 标识符不能以数字开头,不能是java中的关键字。例如: 正确的标识符 Username、username123、user_name、_userName、$username 不正确的标识符: 123username、class、87.2、He...
  • Java继承概念和关键字

    千次阅读 2019-05-07 20:55:39
    继承是java面向对象的三大特征之一,继承可以解决编程中代码冗余的问题,是实现代码重用的重要手段之一。继承是软件可重用性的一种表现,新类可以在不增加自身代码的情况下,通过从现在的类中继承其属性和方法,来...
  • Java50个关键字及解释

    千次阅读 2019-04-28 06:54:49
    Java50个常用关键字及含义 Abstract 抽象的 一个Java语言中的关键字,用在类的声明中来指明一个类是不能被实例化的,但是可以被其它类继承。一个抽象类可以使用抽象方法,抽象方法不需要实现,但是需要在子类中被...
  • java关键字详解

    千次阅读 多人点赞 2018-11-22 15:29:32
    java中有两个特殊的关键字goto、const,我们称这两个关键字为保留字。 二、java中有哪些关键字? 先来介绍几个特殊的关键字,我们称之为访问修饰符。另一个名字被叫做访问控制符。 1.什么是访问修饰符? java...
  • 主要为大家详细介绍了Java微信公众平台开发第九步,关键字回复以及客服接口实现,以及遇到该公众号暂时无法提供服务的解决方案,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 详解java中的关键字

    2019-08-28 21:30:28
    1:Java关键字简介: 在java中有特殊意义的单词 不能作为变量名、方法名、类名存在 在编译器中常被高亮提示 关键字中所有字母都为小写 2:关键词功能分类: 2.1:用于定义【访问权限修饰符】的关键字 private ...
  • Java中的关键字含义以及介绍

    千次阅读 2018-11-19 14:52:23
    Java关键字是有特别意义的标识符。用来表示一种数据类型,或者表示程序的结构等。 Java关键字不能用作变量名、方法名、类名、包名和参数。 以下是Java关键字以及关键字含义: 序号 关键字 含义和介绍 1...
  • java关键字实现原理

    2011-10-15 09:21:38
    作为一个Java程序员,如果不了解JVM的工作原理,就很难从底层去把握Java语言和Java程序的运作机制。这里先推荐一个最 权威的讲解JVM的文档,大家只要查过Java API的可以在里面的一个叫“API, Language, and V...
  • 详细分析Java8中default关键字

    千次阅读 2020-06-01 23:16:11
    目录 一、简介 二、出现的理由 三、例子 三、解决冲突 ...default关键字:与public、private等都属于...通过default关键字定义的方法,集成该接口的方法不需要去实现该方法。 三、例子 创建一个person类, 使用de.
  • java 实现接口

    千次阅读 2018-06-30 10:11:19
    6.2 实现接口 1 类实现接口 在Java语言中,接口由类来实现以便使用接口中的方法。 一个类需要类声明中使用关键字implements声明该类实现个或多个接口。 如果实现多个接口,用逗号隔开接口名,例如A类实现Pintable...
  • Java-default关键字

    2019-09-16 23:56:02
    在学习集合代码时发现在...是指,在接口内部包含了一些默认的方法实现(也就是接口中可以包含方法体,这打破了Java之前版本对接口的语法限制),从而使得接口在进行扩展的时候,不会破坏与接口相关的实现类代码。 为...
  • Java中transient关键字的详细总结

    万次阅读 多人点赞 2018-06-14 22:15:12
    一、概要介绍Java中的transient关键字,transient是短暂的意思。对于transient 修饰的成员变量,在类实例的序列化处理过程中会被忽略。 因此,transient变量不会贯穿对象的序列化和反序列化,生命周期仅存于调用者的...
  • Java常用关键字总结

    千次阅读 2020-02-24 20:22:14
    常用关键字汇总图 详细解释 用于定义访问控制修饰符的关键字 控制范围图 public(公共的) 1、public 关键字是可以应用于类、方法或字段(在类中声明的变量)的访问控制修饰符。 2、可以在其他任何类或包中引用 ...
  • Java中的关键字和保留字(共53个)

    万次阅读 2018-08-22 15:15:37
    Java关键字(Key Word): 对Java的编译器有特殊的意义,他们用来表示一种数据类型或者表示程序的结构. 保留字(Reserve Word):即它们在Java现有版本中没有特殊含义,以后版本可能会作为有特殊含义的词,或者该...
  • 本文参照Java8揭秘(三)Default 方法在java8开发过程中,有件事情就显得非常重要,即在不破坏java现有实现架构的情况下能往接口里增加新方法。引入Default方法到Java8,正是为了这个目的:优化接口的同时,避免跟现有...
  • JAVA全部关键字

    千次阅读 多人点赞 2018-04-03 19:52:16
    零、关键字一览:abstract continue for new switchassert*** default goto* package synchronizedboolean do if private thisbreak double implements protected throwbyte else import public ...
  • JAVA 常见的关键字

    2020-05-18 14:31:59
    JAVA关键字JAVA语言赋予的特殊含义,用作专门用途。 Java关键字全部为小写。 常见关键字: 1.定义数据类型 class 定义类 interface 定义接口 enum 定义枚举类 八大基本数据类型: byte,short,int,long,float, ...
  • 点class在java里面是关键字还是属性?

    千次阅读 2020-04-18 20:52:33
    关于这个问题我相信有很多人跟我一样一直很困...点class在java里面是关键字还是属性? 这里可以认为是Object类的一个属性,从Class objectClass=Object.class;从可以看的出来.而且它和Class objectClass2=d.getClass()...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 291,604
精华内容 116,641
关键字:

java实现接口的关键字

java 订阅