java学习15天

修饰词
1.访问控制修饰符
四个修饰符 private public default protected
2.状态修饰词
static(静态):使用static修饰
非静态:不使用static修饰
修饰方法:
格式: 修饰词 返回值 方法名(方法参数){}
作用:当使用static修饰方法,可以直接通过类名进行调用
结论:

1. 静态方法中不可以直接写方法名调用非静态方法
2. 非静态方法可以直接写方法调用静态方法

修饰变量::
语法格式:状态修饰词 数据类型 变量名:
作用:当使用 static 修饰变量时,则表示该变量属于类,可以直接通类名进行调用
结论:

1. 在静态方法中只能调用静态的资源
2. 非静态的方法可以直接调用静态和非静态的资源

修饰静态代码块
语法格式: 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;
}