1.权限

在Java中提供了四种访问权限，使⽤不同的访问权限修饰符修饰时，被修饰的内容会有不同的访问权限：

public：公共的
protected：受保护的
default（friendly）：默认的，一般不加这个关键词
private：私有的

不同权限的访问能力

2.封装（private）

为了代码跟数据的安全性，防止其他类随意访问本类的信息，就考虑到封装这个方法。

封装步骤：

使用private关键字来修饰成员变量
对需要访问的成员变量，提供对应的一对get();/set();方法

上面说到private是最小权限，它能修饰成员变量跟成员方法，被它修饰后，只能在本类中访问。

封装优化：1.this.关键字 2.构造方法 ——>详细见文章 java day05

权限、封装代码说明


//关于权限
/*
* 1.public
* 2.protected
* 3.default
* 4.private
* */
public class Qx {public int n_public = 1;protected int n_protected = 2;int n_default = 3;private int n_private = 4;//封装获得方法public int getN_private(){return n_private;}//封装获得方法public void setN_private(int n_private){this.n_private = n_private;}//给不同包下的子类使用public int getN_default(){return n_default;}public void setN_default(int n_default) {this.n_default = n_default;}//给不同包没有关系的类使用public int getN_protected() {return n_protected;}public void setN_protected(int n_protected) {this.n_protected = n_protected;}//成员方法public void s1(){System.out.println(n_public);System.out.println(n_protected);System.out.println(n_default);System.out.println(n_private);}}
//这里是同包 没有关系的类
public class Test01 {public static void main(String[] args) {Qx qx = new Qx();System.out.println(qx.n_public);System.out.println(qx.n_protected);System.out.println(qx.n_default);//访问不到private私有的成员变量，它只能在它所在的类里被访问qx.s1();  //1 2 3 4 //但好像能调用含private的成员方法//在没有封装get，set方法前，私有变量是访问不了的，之后通过这两个方法就能访问了System.out.println(qx.getN_private());//获得私有成员变量4qx.setN_private(8);//修改私有成员变量System.out.println(qx.getN_private());//8被修改了qx.s1();//1 2 3 8}
}//同包，继承Qx的子类
public class Test02 extends Qx {public static void main(String[] args) {Qx qx = new Qx();System.out.println(qx.n_public);System.out.println(qx.n_protected);System.out.println(qx.n_default);qx.s1();qx.setN_private(6);qx.getN_private();}}
import day07.a_publictest.Qx;//这里是不同包下,继承Qx子类调用测试
public class Test03 extends Qx {public void m3(){System.out.println(n_public);System.out.println(n_protected);//只能访问上面两种类型的成员变量getN_default();getN_private();}
}import day07.a_publictest.Qx;//不同包，也没有关系的类
public class Test04 {public static void main(String[] args) {Qx qx = new Qx();System.out.println(qx.n_public);//只能访问到公开成员变量qx.getN_private();qx.getN_default();qx.getN_protected();}
}

3.JavaBean

JavaBean是Java语言编写的一种标准规范，符合标准规范的类，要求类必须是具体的和公共的，并且具有无参数的构造方法，提供用来操作成员变量的set和get方法。

public class ClassName {

// 成员变量

// 构造⽅法

// ⽆参构造⽅法【必须】

// 有参构造⽅法【建议】

// 成员⽅法

// getXxx()

// setXxx()

}

4.static关键字（静态的）

static可以修饰：成员变量，成员方法，代码块，内部类

1.定义

类变量：使用static关键词修饰的成员变量：static 数据类型变量名;

类方法（静态方法）：使用static关键字修饰的成员方法

修饰符 static 返回值类型⽅法名 (参数列表) {

// 执⾏语句

}

2.调用

// 访问类变量属于类

类名.类变量名;

// 调⽤静态⽅法

类名.静态⽅法名(参数);

注意：

1.静态⽅法可以直接访问类变量和静态⽅法。

2.静态⽅法不能直接访问普通成员变量或成员⽅法。反之，成员⽅法可以直接访问类变量

或静态⽅法。

3.静态⽅法中，不能使⽤this关键字。静态⽅法只能访问静态成员。

代码说明

public class Main01 {public static void main(String[] args) {Demo01 d = new Demo01();//用对象.变量名/方法名 只能调用普通成员变量跟普通成员方法 属于对象d.name = "luck";d.m1();//luck0//用类名.变量名/方法名 就能调用静态成员变量跟静态成员方法 属于类Demo01.age = 12;Demo01.m2();//12//下面在给静态成员变量赋值后再一次调用普通成员方法，就有一样的值了d.m1();//luck12}
}
//关于静态static修饰词
/*
* 1.静态成员变量
* 2.静态成员方法
* */
public class Demo01 {//普通成员变量String name;//静态成员变量static int age;//构造方法Demo01(){}Demo01(String name){this.name=name;Demo01.age=age;//因为是静态成员变量不能用this关键字只能 类名.变量名m2();}//普通成员方法public void m1(){//在普通成员方法里可以调用静态成员变量跟静态成员方法m2();System.out.println(name + age);}//静态成员方法public static void m2(){//m1();//编译报错 说明在静态成员方法里不能调用普通成员方法//System.out.println(name);//编译报错 说明在静态成员方法里不能调用普通成员变量System.out.println(age);}
}

3.静态内存图

4.静态代码块

代码块：
1.执行在构造方法之前
2.作用：给成员变量初始化，提取所有构造方法中重复的代码
静态代码块：1.在类加载时执行：a.实例化对象 b.使用静态方法 c.使用静态变量 2.作用: 优化代码,提升程序效率 3.静态代码块可以有无数个，但只进行一次性的加载，只有一个 4.在静态代码块中不能调用非静态成员变量。

静态代码块和静态变量的执行顺序：先写那个先执行那个

注意: 静态变量先执行，是可以进行运算操作
静态代码块先执行，是不可以进行运算操作，因为变量未定义，所以一般先定义静态变量

代码说明

public class Main02 {public static void main(String[] args) {Demo02 demo02 = new Demo02();//1.执行静态代码块（只会执行一次）2.执行代码块3.执行无参构造demo02.a = 5;}
}
//代码块
//静态代码块
//执行顺序
public class Demo02 {//成员变量int a;static int b;//静态成员变量//静态代码块static {System.out.println("执行父类静态代码块");}//代码块{System.out.println("执行父类代码块");}//构造方法Demo02(){System.out.println("执行父类无参构造");}Demo02(int a){System.out.println(a+"执行父类有参构造");}

父子类代码块执行顺序：父类静态代码块 -> 子类静态代码块 -> 父类代码块 -> 父类构造方法 -> 子类代码块 -> 子类构造方法

代码说明

//父类子类代码块执行顺序
public class Main03 {public static void main(String[] args) {Demo03 demo03 = new Demo03();/*1.执行父类静态代码块2.执行子类静态代码块3.执行父类代码块4.执行父类无参构造5.执行子类代码块6.执行子类无参构造*/}
}
//代码块父子类执行顺序
public class Demo03 extends Demo02{int b;//静态代码块static {System.out.println("执行子类静态代码块");}//代码块{System.out.println("执行子类代码块");}//构造方法Demo03(){System.out.println("执行子类无参构造");}Demo03(int b){System.out.println(b+"执行子类有参构造");}}

5.final关键字（最后的，不可被改变的）

可以修饰：类，成员变量，局部变量，成员方法

类：被修饰的类，不能被继承。

⽅法：被修饰的⽅法，继承后，不能被重写。

变量：被修饰的变量，不能被重新赋值。

基本数据类型：值不可被修改

引用数据类型：地址值不可被修改，但其对应对象的内容可被修改

代码说明

1.基本数据类型

//final关键词
// //final修饰基本数据类型
public class Demo01 {public static void main(String[] args) {//final修饰基本数据类型int a = 10;System.out.println(a);//10a = 20;System.out.println(a);//20 普通变量能被重新赋值final int b = 10;//final修饰的int类型值就不可变了// b = 30;//编译报错 因为被final修饰了final int c;c = 30;//这样赋值是可以被允许的// c = 40;//当第二次赋值就不行了}}

2.引用数据类型

import java.util.Arrays;//final修饰的引用数据类型
//数组
public class Demo02 {public static void main(String[] args) {//普通数组int[] arr = new int[]{11,22,5};arr = new int[]{55,22};//可以被重新修改内容，长度等//final修饰的数组final int[] brr = new int[]{22,55,4};System.out.println(Arrays.toString(brr));//[22, 55, 4]System.out.println(brr);//地址值[I@50cbc42f//brr = new int[]{1,2,3};不被允许brr[0] = 2;//但里面的元素可以被改变System.out.println(Arrays.toString(brr));//[2, 55, 4]System.out.println(brr);//[I@50cbc42f//所以数组不可变的是他的地址值}
}

3.final父子类继承对象

//final修饰的对象
public class Demo03 {public static void main(String[] args) {final Student stu = new Student();stu.age = 5;stu.name = "lucy";//成员变量可以重新赋值// stu = new Student();不允许 因为地址值改变了Student stu1 = new Student();//stu1.f1();//fuf1111stu1.f2();//fuf222ZiStudent ziStu = new ZiStudent();ziStu.f1();//被重写的f1//fuf1111//6666}}
public  class Student {int age;String name;//final int id;//-->这样的编码会报错，因为成员变量自己有初始值，如果用了final修饰就必须给他初始化final  int id = 123456;public void f1(){System.out.println("fuf1111");}//final修饰的成员方法也不能被继承的子类重写public final void f2(){System.out.println("fuf222");}}
public class ZiStudent extends Student{@Override//父类普通成员方法重写public void f1() {super.f1();System.out.println("6666");}//final修饰的成员方法也不能被继承的子类重写// public final void f2() {//super.f1();// }
}

JAVA day07 权限，封装，JavaBean（规范代码），static、final关键字相关推荐

我对static/final关键字的理解（一个类不同的对象，static修饰的变量，在一个对象中被改变了，对其他对象有无影响？）
我对static/final关键字的理解一.static关键字 1.1 static关键字可以修饰的 static关键字可以修饰成员变量.成员方法.初始化块.内部类,被static修饰的成员是类的成 ...
-1-2 java 面向对象基本概念封装继承多态变量 this super static 静态变量匿名对象值传递初始化过程代码块 final关键字抽象类接口
java是纯粹的面向对象的语言也就是万事万物皆是对象程序是对象的集合,他们通过发送消息来相互通信每个对象都有自己的由其他的对象所构建的存储,也就是对象可以包含对象每个对象都有它的类型也就是 ...
Java基础-day08-static·static静态代码块·final 关键字·多态·汽车设计综合案例·异常
day09 1.static 是java中的一个关键字用于修饰成员(成员变量和成员) 1.static是一个关键字 2.static可以修饰成员变量和方法,被修饰的资源就是静态资源 3.静态资源优先 ...
java static final关键字_Java的static与final关键字
版权声明:转载原创文章请以超链接形式请注明原文章出处,尊重作者,尊重原创! 恰饭广告 static:(静态修饰符)面向对象中static修饰的内容是隶属于类,而不是直接隶属于对象的,所以static修 ...
黑马程序员_Java基础_this,super,static,final关键字
一,this关键字 1,当成员变量和局部变量重名时,可以使用this关键字来区分. this关键字代表的是本类对象,this一般是在一个函数中,哪个对象在调用this所在的函数,this就代表哪个对象 ...
java提升权限运行_提升代码的运行权限，实现模拟管理员身份的功能
SPSecurity.RunWithElevatedPrivileges(delegate() { // implementation details omitted }); 可以提升代码的运行权限, ...
JAVA类的继承、覆写和final关键字
extends不用多说,是来继承的关键字,但它有几个要点: java不允许多重继承(一个类只能继承一个父类,不能继承多个父类) 派生类会继承基类所有属性和方法,但不能直接访问基类的private私有属 ...
《java入门第一季》之面向对象（final关键字）
/*final可以修饰类,方法,变量特点:final(可以修饰类),该(类)(不能被继承).一旦修饰了一个类,这个类就不能被继承了!final以修饰方法,该方法可以被继承但是不能被重写.(覆盖,复写) ...
Java笔记017-类变量和类方法、理解main方法语法、代码块、单例设计模式、final关键字
目录面向对象编程(高级部分) 类变量和类方法类变量-提出问题传统方法解决问题分析: 类变量快速入门类变量内存布局什么是类变量如何定义类变量定义语法: 如何访问类变量定义语法: 类变量使 ...

JAVA day07 权限，封装，JavaBean（规范代码），static、final关键字

1.权限

2.封装（private）

3.JavaBean

4.static关键字（静态的）

5.final关键字（最后的，不可被改变的）

JAVA day07 权限，封装，JavaBean（规范代码），static、final关键字相关推荐

最新文章

热门文章