Java基础之25个重要关键字总结+实例讲解

Java重要关键字总结

一.控制访问

1.private：私有模式

被private修饰的属性，只能在类内部直接访问，外部无法直接访问
外部访问private修饰的属性必须调用该属性的，set和get方法从而间接访问

User类

public class User {
    private Integer age=18;

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    private String name="WTMC";
    //类内部直接访问age和name属性
    public void test(){
        System.out.println("age:"+age);
        System.out.println("name:"+name);
    }
}

Main方法访问User类的私有变量

public class Main {
    public static void main(String[] args) {
        User user = new User();
        //外部间接访问user对象的private属性
        System.out.println(user.getAge());
        System.out.println(user.getName());

        //user对象内部直接访问private属性
        user.test();
    }
}

2.Default：默认模式(不声明任何访问控制的时候)

被defalut修饰的属性，可以在类对象的内部或者同一个包下直接访问

User类

public class User {
    //不声明访问控制，默认是default
    Integer age=18;
    //类内部直接访问default修饰的变量age
    public void test(){
        System.out.println(age);
    }
}

Main类

public class Main {
    public static void main(String[] args) {
        User user = new User();
        //同一个包下直接访问user对象的default属性
        System.out.println(user.age);

        //user对象内部直接访问default属性
        user.test();
    }
}

3.protected：受保护模式

protected修饰的属性，可以在类内部，同一个包下，以及子类直接访问

User类

public class User {
    protected Integer age=18;
    //对象内部直接访问，protected属性age
    public void test(){
        System.out.println(age);
    }
}

People类(User的子类)

public class People extends User{
    //子类访问父类的protected属性age
    public void test(){
        System.out.println("父类的age："+super.age);
    }
}

Main类

public class Main {
    public static void main(String[] args) {
        User user = new User();
        People people = new People();
        //同一个包下直接访问user对象的protected属性
        System.out.println(user.age);

        //user对象内部直接访问protected属性
        user.test();

        //子类访问父类的protected属性
        people.test();
    }
}

4.public：公用模式

public修饰的属性，在整个module中都可以使用，不局限与任何地方

注意：对于顶级类(外部类)来说，只有两种修饰符：public和默认(default)。因为外部类的上一单元是包，所以外部类只有两个作用域：同包，任何位置。因此，只需要两种控制权限：公开访问权限和包控制权限，也就对应两种控制修饰符：public和默认(default)。可以满足所有的情况了。

二.8个Java基本类型

5.int(整型32位)

int用于修饰整型变量，它的封装类是Integer

int和Integer的区别
1.Integer是int的包装类(是一个类),而int则是一个基本数据类型
2.Integer的默认值是null，int的默认值是0
3.Integer必须实例化才能使用(否则可能空指针异常)，而int则不需要
4.Integer实际是对象的使用，当实例化Integer而new一个Integer对象的时候，实际上是把对象的地址值储存到内存，而int则是直接储存值

6.long(长整型64位)

long用于修饰整型变量，它的封装类是Long

7.float(单精度浮点型32位)

float用于修饰整型变量，它的封装类是Float

8.double(双精度浮点型64位)

Double用于修饰整型变量，它的封装类是double

9.char(字符型16位)

char用于修饰字符型变量，它的封装类是Character

10.short(短整型16位)

short用于短整型变量，它的封装类是Short

11.boolean(布尔型8位)

boolean用于布尔型变量，其值只有true或false，它的封装类是Bool

12.byte(字节型8位，占一个字节)

byte用于字节型变量，它的封装类是Byte

三.程序逻辑

13.Continue

同行用于跳出循环的当前遍历

public class Main {
    public static void main(String[] args) {
        for(int i=1;i<=10;i++){
            //当i等于1是不输出
            if(i==1) continue;
            System.out.println(i);
        }
    }
}

14.break

跳出整个循环

public class Main {
    public static void main(String[] args) {
        for(int i=1;i<=10;i++){
            //当i等于5是结束for循环
            if(i==5) break;
            System.out.println(i);
        }
    }
}

四.类的类型修饰和继承

15.abstract(抽象)

abstract用于修饰抽象类和抽象方法

抽象类的普通类的区别：
1.抽象类可以有抽象方法(只声明不实现)，而普通类不能
2.抽象类的抽象方法可以没有方法体，但是普通类的方法必须要有方法体

抽象类的实现

public abstract class Dog {
    private String name;
    //抽象方法，只声明不是实现,没有方法体
    public abstract void talk();
    public void bark(){
        System.out.println(name+"正在汪汪汪");
    }
}

16.interface(接口)

interface关键字用于什么一个接口

接口中的所有方法都没有方法体，只什么不实现

接口类实现

public interface Student {
    public void talk();
    public void eat(String food);
}

17.extends(继承)

extends用于实现类的继承

继承的详解~~~~待更新(放超链接)

18.implements(实现)

implements用于定义接口的实现类

实现类的详解~~~~待更新(放超链接)

19.final(最终)

被final修饰的类不可以被继承，被final修饰的方法不能够被重写，被final修饰的属性不能被修改

五.其余重要关键字

20.static(静态)

1.static修饰变量(成为静态变量)

静态变量和非静态变量的区别，类的静态变量被此类的所有对象所共享，也就是说此类所创建的所有类的静态变量都是同一个，在内存中只有一个副本，当类加载时创建

2.static修饰成员方法(静态方法)

特点：
1.静态方法只能访问静态成员变量，不能访问非静态成员变量，而普通方法都可以访问.
2. 调用静态方法可以不用创建对象，直接调用，语法：类.静态方法.
User类

public class User {
    private static Integer num=0;
    public static void addnum(){
        num++;
        System.out.println("num="+num);
    }
}

Main类

public class Main {
    public static void main(String[] args) {
        for(int i=1;i<=10;i++) {
            User.addnum();
        }
    }
}

结果

3.static创建静态代码块

静态代码块特点：
1.静态代码块内部和静态方法一样只能访问静态变量.
2.静态代码块无需手动调用，在类被加载时就自动调用了.
User类

public class User {
    private static Integer num=0;
    public static Integer getNum() {
        return num;
    }

    //静态代码块,把num复制为10
    static{
        num  = 10;
    }
}

Main 类

public class Main {
        public static void main(String[] args) {
            System.out.println(User.getNum());
        }
    }

结果

21.instanceof

instanceof用于判断两个类型之间是否具有父子类关系
1.父类转子类，需要强制转换.
2.子类转父类，可能会丢失一些子类的一些方法及变量.
3.object是任何类的父类
判断语法：对象名 instanceof 类名

public class Teacher extends People{
}

public class Student extends People{
}

public class Main {
        public static void main(String[] args) {
            Object student = new Student();
            Object teacher = new Teacher();
            Object object = new Object();
            People people = new People();
            System.out.println(student instanceof People);
            System.out.println(teacher instanceof People);
            System.out.println(student instanceof Teacher);
            System.out.println(student instanceof Object);
            System.out.println(teacher instanceof Object);
            System.out.println(people instanceof Object);
            System.out.println(object instanceof Object);
        }
    }

22.synchronized(同步)

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

synchronized用法~~~~~~待更新(放超链接)

23.throws(抛出所有异常)

throws修饰方法，表示这个方法需要抛出所有的异常类型

//抛出所有的Exception类型的异常
        public int div(int i,int j) throws Exception{
            int ans = i/j;
            return ans;
        }

24.throw(抛出一个异常)

public int div(int i,int j){
            int ans = 0;
            try {
                ans = i/j;
            } catch (Exception e) {
                e.printStackTrace();
                //抛出一个RuntimeException异常
                throw new RuntimeException();
            }
            return ans;
        }

25.assert(断言)

断言是用于调式的函数，并非java程序中的必要所在，如果想要学习如何使用断言来调式程序可以自行百度学习