20211122

☞词穷

已于 2023-07-19 06:49:14 修改

阅读量159

点赞数

分类专栏： Java 文章标签： java javase

于 2021-11-26 02:53:15 首次发布

本文链接：https://blog.youkuaiyun.com/qq_44790259/article/details/121551527

版权

Java 专栏收录该内容

4 篇文章

订阅专栏

今日内容：

关键字：

static

静态，修饰变量、方法的
被修饰的内容是类的成员

class Demo1 
{
    public static void main(String[] args) 
    {
        A.age = 13;
    }
}
class A
{
    static int age;   //静态关键字：static
}

static修饰的内容随类的加载而加载

class Demo2 
{
    public static void main(String[] args) 
    {
        A a;   //static 修饰的内容随类的加载而加载
    }
}
class A
{
    //静态方法
    public static void A()    //关键字：static
    {}
}

注意事项：

非静态的可以访问静态的

静态的不能访问非静态的、

/*
class Demo3 
{
    public static void main(String[] args) 
    {
        //A.A();     //静态的访问非静态的·   不行

    }
}
class A
{
    //static int age = 13;
    int age = 13;
    //public void A()
    public static void A()
    {
        System.out.println("年龄："+age);
    }
}
*/
class Demo3 
{
    public static void main(String[] args) 
    {
        A a = new A();   //非静态的访问静态的
        a.A();

    }
}
class A
{
    static int age = 13;
    //public void A()
    public static void A()
    {
        int age = 24;
        System.out.println("年龄："+age);
        System.out.println("年龄："+this.age);   //不能使用
        System.out.println("年龄："+super.age);   //不能使用
    }
}

static修饰的方法中不能使用static 关键字

final：

固定地址值，最终值

class Demo4 
{
    public static void main(String[] args) 
    {
        final int a = 3;
        a = 4;
        int b = 4;
        b = 6;
    }
}

特点：

变量是个常量

class  Demo5
{
    public static void main(String[] args) 
    {
        B b = new B();
        b.age = 33;  //可以被继承，但是不能改变，这是个常量
    }
}
class A
{
    final int age = 23;
}
class B extends A
{
}

类不能被继承

class Demo6 
{
    public static void main(String[] args) 
    {
        System.out.println("Hello World!");
    }
}
final class A   //无法继承  最终A
{
}
class B extends A
{
}

方法可以继承，但不能重写

class Demo7 
{
    public static void main(String[] args) 
    {
        B b = new B();
        b.A();
    }
}
class A
{
    public final void A()
    {
        System.out.println("A -------B");
    }
}
class B extends A
{
    /*public void A()
    {
        System.out.println("");
    }
    */
}

代码块：

 ```java
 以{}括起来的内容
 按{}在程序中的位置   把代码分成四种
 ```

普通代码块

定义在程序的方法内

class Demo9 
{
    public static void main(String[] args) 
    {
        //普通代码块
        {
            System.out.println("这是普通代码块");
        }
        System.out.println("这是普通代码块");
    }
}

普通代码块和其他程序流程一样，从上至下执行

构造代码块

定义在类内方法外部，与类的成员变量、成员方法同级

class Demo10 
{
    public static void main(String[] args) 
    {
        //Demo10 d = new Demo10();
        A a = new A();
    }
    
}
class A
{
    //构造代码块
    {
        System.out.println("这是构造代码块");
    }
}

构造代码块和构造方法的执行顺序

class Demo10 
{
    public static void main(String[] args) 
    {
        //Demo10 d = new Demo10();
        A a = new A();
    }
    
}
class A
{
    //构造代码块
    {
        System.out.println("这是构造代码块");
    }
    public A ()
    {
        System.out.println("这是构造方法");
    }
}

先执行构造代码块，再执行构造方法，，，，构造代码块优先于构造方法

和写的顺序没有关系

构造代码块和new的关系：new几次走几次

class Demo10 
{
    public static void main(String[] args) 
    {
        //Demo10 d = new Demo10();
        A a = new A();
        A a1 = new A();
    }
    
}
class A
{
    //构造代码块  和类中变量同级  即类中方法外
    {
        System.out.println("这是构造代码块");
    }
    public A ()
    {
        System.out.println("这是构造方法");
    }
    //和构造方法一样，new几次走几次
}

静态代码块

类中方法外和static同级

class Demo11 
{
    public static void main(String[] args) 
    {
        A a = new A();
        A a1 = new A();
        A a2 = new A();
    }
}
class A
{
    //静态代码块
    static {     //类中方法外
        System.out.println("这是静态代码块");
    }
}

new多少次，他都是只走一次

静态代码块和构造代码块、构造方法执行顺序

class Demo11 
{
    public static void main(String[] args) 
    {
        A a = new A();
        A a1 = new A();
        A a2 = new A();
    }
}
class A
{
    //静态代码块
    static {     //类中方法外
        System.out.println("这是静态代码块");
    }
    //构造方法
    public A ()
        {
            System.out.println("这是构造方法");
        }
    //构造代码块
    {
        System.out.println("这是构造代码块");
    }
}

优先级：静态代码块》构造代码块》构造方法和写的顺序没关系！！！

同步代码块（多线程讲）

内部类：

含义：类包含类，被包含的类是内部类

成员内部类

类中类和变量同级，类中方法外

class Demo13
{
    public static void main(String[] args) 
    {
        //使用
        A.B a = new A().new B();
    }
}
class A
{
    //成员内部类  类中方法外
    class B
    {
    }
}

成员内部类的使用

class Demo14 
{
    public static void main(String[] args) 
    {
        //使用成员内部类
        A.B a = new A().new B();
        a.B();
    }
}
class A
{
    int a = 10;
    class B
    {
        int a = 20;
        public void B()
        {
            int a = 30;
            System.out.println("a:"+a);
            System.out.println("a:"+this.a);
            System.out.println("a:"+A.this.a);
        }
    }
    public void B()
    {
        //System.out.println("b:"+b);
        System.out.println("a:"+new B().a);
    }
}

成员内部类可以使用类外部定义的数据

类外部不能直接使用类内部定义的数据，需要new一下

局部内部类

方法中的类

class Demo16 
{
    public static void main(String[] args) 
    {
        A a = new A();
        a.A();
    }
}
class A
{
    int a = 10;
    //public B A();
    public void A()
    {
        class B
        {
            int a = 10;
            public void show()
            {
                int a = 10;
                System.out.println("这是局部内部类");
            }
        }
        new B().show();
        //return new B();   //不能加任何修饰符
    }
}

不能加任何修饰符

要在方法类内部类外进行一个实例化

匿名内部类

类内方法里常用于接口抽象类

class Demo17 
{
    public static void main(String[] args) 
    {
        //匿名内部类
        /*new A(){
            public void A()
            {
                System.out.println("A----重写----A");
            }
        }.A();*/
        A a = new A(){
            public void A()
            {
                System.out.println("A-----重写-------A");
            }
        };
        a.A();
    }
}
class A
{
    public void A(){
        System.out.println("A-------A");
    }
}

匿名内部类的使用

class Demo18 
{
    public static void main(String[] args) 
    {
        A a = new A(){
            public void A(){
                System.out.println("我把接口A方法重写了");
            }
        };
        a.A();
    }
}
interface A
{
    public void A();
}