修饰词
1.访问控制修饰符
四个修饰符 private public default protected
2.状态修饰词
static(静态):使用static修饰
非静态:不使用static修饰
修饰方法:
格式: 修饰词 返回值 方法名(方法参数){}
作用:当使用static修饰方法,可以直接通过类名进行调用
结论:
- 静态方法中不可以直接写方法名调用非静态方法
- 非静态方法可以直接写方法调用静态方法
修饰变量::
语法格式:状态修饰词 数据类型 变量名:
作用:当使用 static 修饰变量时,则表示该变量属于类,可以直接通类名进行调用
结论:
- 在静态方法中只能调用静态的资源
- 非静态的方法可以直接调用静态和非静态的资源
修饰静态代码块
语法格式: static {方法块}
作用:用于初始化静态变量
public class Demo01 {
public static void main(String[] args) {
//1.创建对象 非静态
//2.通过对象调用方法
Aoo aoo=new Aoo();
aoo.test();
aoo.name="123";
Aoo.id=12;//静态的id,可以直接通过类名进行调用
//1.直接通过类名进行调用 静态
Aoo.staticTest();
}
}
class Aoo{
static int id;//静态的成员变量
String name;//非静态成员变量
public void test(){
System.out.println("非静态方法test");
//可以直接调用静态方法
staticTest();
//非静态方法中可以直接写方法名调用静态方法
}
public static void staticTest(){
System.out.println("静态方法test");
//不可以直接调用非静态方法
//test();报错,
//this.test();报错,因为static方法不认识this(因为静态方法属于类,不认识this对象)
//为什么静态方法中不能调用非静态方法
//1.非静态方法是需要通过对象进行调用的
//2.方法使用static,没有this的概念了
//3.所以static方法中不可以直接写方法名调用非静态方法
id=100;
//name="123";报错 静态方法中不可以调用非静态的资源
}
public void testAoo(){
//非静态方法可以直接调用非静态方法
//this:在非静态方法中有隐式的this传递
//this:指代当前类对象
test();//==this.test();
id=100;
name="123";
}
}
final:最终的 不可被继承
修饰类:该类不能被继承(不可有子类和孙子类,但可以有父类)
修饰方法:该方法不能被重写,但是可以被重载
修饰变量:表示该变量只能赋值一次,不能再次赋值
public class Demo03 {
public static void main(String[] args) {
Goo g=new Goo();
}
}
class Goo{
final int b;
//成员变量b使用final修饰,则要么再声名的时候初始化,要么在构造放法里手动初始化,而且只能初始化一次
public Goo(){
this.b=12;
}
public final void test(){
final int a;//a使用final修饰,则a值只能赋值一次
a=12;
//如果使用final修饰方法,
//所以该方法是最终形态,所以不能重写
}
public final void test(int a){
//重载,如果使用final修饰当前的方法,
//所以该方法是带参数的最终形态,所以不能被重写
}
}
final class Coo extends Goo{
}
//class Doo extends Coo{
// 因为Coo用final修饰,所以在这里Doo不能继承Coo
//}
封装:属性私有化.提高数据安全性
把代码用方法封装起来,隐藏了具体的实现
调用者直接调用该方法即可,不必过于关注过程
通过get和set来进行数据的修改和查询
public class Demo04 {
public static void main(String[] args) {
Yoo y=new Yoo();
y.id=10;
ABC abc=new ABC();
//abc.num=20 ;num已被隐藏
}
}
class Yoo{
public int id;
public String name;
}
class ABC{//中国农业银行的简称
private String pwd;//密码
private String num;//余额
/*
当前类中pwd和num信息被隐藏,不允许外部程序直接访问
通过该类提供的方法,实现对隐藏数据的操作和访问
*/
//修改和查询
//修改
public void setPwd(String pwd){
this.pwd=pwd;
}
//查询
public String getPwd(){
return pwd;
}
public void setNum(String num){
this.num=num;
}
public String getNum(){
return num;
}
}
class ICBC{
//alt+insert
private String name;
private int age;
}
小案例:
public class StaticDemo01 {
static int a=10;
public static void main(String[] args) {
System.out.println(a);
/*
调用Boo中静态的id
没有使用特殊的结果去给静态成员变量初始化,
而是放在了构造方法中初始化成员变量,
导致在使用之前必须还做一个对象,没有很好的呈现static修饰的好处
*/
System.out.println("Boo="+Boo.id);//
Boo.id=999;
Boo b1=new Boo();
b1.age=18;
Boo b2=new Boo();
Boo b3=new Boo();
b3.age=30;
System.out.println(b1.age);
System.out.println(b2.age);
System.out.println(b3.age);
System.out.println(Boo.id);
/*
上述通过Boo类型创建了三个Boo对象,所以会执行三次构造方法
*/
}
}
class Boo{
int age;//非静态的成员变量,在构造方法中初始化
static int id;//静态的成员变量
static {
id=888;
//age=10;只能放static修饰的变量
System.out.println("Boo的静态代码---");
}
public Boo(){
age=10;
System.out.println("Boo的构造方法,正在初始化非静态成员变量");
}
}
public class StaticDemo02 {
public static void main(String[] args) {
Eoo e=new Eoo();
/*
1.类一旦被加载,就会去执行静态代码块
2.先执行父类静态代码块再加载子类代码块
因为子类需要使用父类的静态资源
*/
}
}
class Foo{
static {//类被加载的时候静态代码块就会被执行,创建本类对象或者该类的子类的对象时,类就会被加载
System.out.println("Foo的static");
}
public Foo(){
System.out.println("Foo的构造方法");
}
}
class Eoo extends Foo{
static {
System.out.println("Eoo的static");
}
public Eoo(){
System.out.println("Eoo的构造方法");
}
}
static final 可以用来修饰变量
一旦使用static final 修饰变量之后,那么该变量就成了常量,必须定义的时候初始化
取名建议:常量的每个字母都大写,为了区分普通的成员变量
public class StaticFinalDemo {
public static void main(String[] args) {
//Hop.id=12;final修饰不可被更改
System.out.println(Hop.ID);
}
}
class Hop{
static final int ID = 0;
}