JAVA语法二：封装，static成员，代码块，内部类

崽_85

已于 2022-08-07 16:13:34 修改

阅读量238

点赞数 10

分类专栏： java 文章标签： java 开发语言

于 2022-08-07 10:00:00 首次发布

本文链接：https://blog.csdn.net/qq_56701924/article/details/126180959

版权

java 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

1：封装的概念

面向对象程序的三大特性：封装，继承，多态。

封装：对类内部的实现细节进行封装，对外只提供一些公开的接口。

NO	范围	private	default	protected	public
1	同一包的同一类	Y	Y	Y	Y
2	同一包中不同类	N	Y	Y	Y
3	不同包中子类	N	N	Y	Y
4	不同包中的非子类	N	N	N	Y

Y:可以 N：不可以

说明：访问限定符只是对权限的限定。这些限定符都可以修饰类名，修饰方法，修饰成员变量。

default：默认值，对包内进行访问。

private: 私有制的，只能在类的内部进行访问。

2.包的概念

1.使用import语句导入包

例如：import .java.util.Arrays,这是导入一个具体的包。

import .java.util*,你将用到谁，就会导入具体的包。

2.import static 导入包中静态的方法和字段。

注意：

import 语句可以导入具体的类，不可以导入具体的包。

3.static成员

3.1：static修饰成员变量

static 修饰的成员变量，称为静态成员变量。

静态成员变量最大的特性：不属于莫个具体的对象，是所有对象的共享。

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

猜一下，这道题输出是多少，

是false------静态成员未没有初始化，会有默认值，但局部变量没有初始化，会报错。

3.2：static 修饰成员方法

注意：

static 修饰类的变量和类的方法。

不赋值，默认是NULL，不依赖于对象。

public class Main {
    public static void main(String[] args) {
        Test test=null;
        test.hello();
    }
    class Test {
        public static void hello() {
            System.out.println("hello");
        }
    }
｝

看看这道题，猜这道题会输出啥？

输出的是hello-------static修饰成员方法，不依赖于对象，可以用类名+点+成员方法。

public class HasStatic {// 1
     private static int x = 100;// 2
     public static void main(String args[]) {// 3
         HasStatic hsl = new HasStatic();// 4
         hsl.x++;// 5
         HasStatic hs2 = new HasStatic();// 6
         hs2.x++;// 7
         hsl = new HasStatic();// 8
         hsl.x++;// 9
         HasStatic.x--;// 10
         System.out.println(" x=" + x);// 11
     }
 }

从这道题可以知道，静态成员变量在方法区。

静态方法的特征

1，不属于莫个具体的对象，是类方法。

2，可以通过对象调用，可以通过类名，静态方法名的方式调用。

3，不可以在静态方法中访问任何非静态成员变量。

4.代码块

4.1：代码块的分类

1.实例代码块---代码块

2,静态块----static修饰,一般初始化静态变量。

4.2：静态代码块

ublic class HasStatic {// 1
         static int cnt = 6;//静态变量
         static{//静态代码块(第一个静态代码块）
             cnt += 9;
         }
         public static void main(String[] args){
             //{} 这是普通代码块
             System.out.println("cnt = " + cnt);
         }
         static{//第二个静态代码块
             cnt /=3;
         };
}

这个输出的是5。

是因为：先运行静态代码块（在类创建时就是运行），之后是实例代码块，最后是构造方法。

注意事项：

1.静态代码块不管生成多少个对象，只会执行一次。

2.如果一个类中包含多个静态代码块，编译器按照定义的先后次序依次执行。

3.实例代码块只有在创建对象时才会执行。

5.内部类

5.1：内部类的分类

1.实例内部类-----未被static修饰。

2.静态内部类-----被static修饰。

3.局部内部类

5.2：实例内部类

public class OutClass {
    private int a = 10;//原地复制
    static int b = 20;
    int c = 30;
    public void method() {
        System.out.println("OutClass::method");
    }
    class IntClass {//实例内部类
        int d = 40;
        int c;//这里和外部类的成员变量同名。
        public void method2() {
            a = 100;
            b = 200;
            System.out.println(a+" "+b+" "+OutClass.this.c+" "+d);
           //OutClass.this.c：这里是调用外部类的c
            method();//调用外部类的方法
        }
    }
    public static void main(String[] args) {
        OutClass c1=new OutClass();//闯将外部类对象c1;
        System.out.println(c1.a);
        System.out.println(c1.b);
        System.out.println(c1.c);//调用外部类的成员变量
        OutClass.IntClass c2=c1.new IntClass();//这里是先创建了外部类对象
                                               //这里是创建实例内部类对象c2;
        //如果木有先创建外部类对象，创建实例内部类对象c3;
        //OutClass.IntClass c3=new OutClass().new IntClass();
        c2.method2();//调用内部类的方法
    }
}

注意：

1.实例内部类不能有静态成员变量。非要定义，只能用 static final 修饰

2.如果实例内部类访问外部类相同名的成员变量，外部类的类名.this.成员变量.

3.外部类中的任何成员都可以直接在实例内部类方法中直接访问。

4.实例内部类对象必须在先有外部类对象前提下才能创建。

5.外部类，不能直接访问内部类的成员，如果访问，必须创建内部类对象

5.3：静态内部类

public class OutClass1 {
    private int a = 10;
    static int c;
    public void method() {
        System.out.println(a+" "+c);
    }
    static class IntClass {//静态内部类
        static int d = 100;
        public void method1() {
            //a = 100;//这里报错了，因为a不是静态变量。
            c = 200;
           // method();//这里报错，因为这个不是静态内部类的成员方法。
            System.out.println(c+" ");
        }
    }

注意事项：

1.在静态内部类中只能访问外部类中的静态成员。

2.创建静态内部类对象时，不需要先创建外部类的对象。