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程序中的必要所在,如果想要学习如何使用断言来调式程序可以自行百度学习