static-extends-权限修饰符-final-变量-常量-接口-正则表达式

最新推荐文章于 2024-10-16 10:13:45 发布

清冬初行

最新推荐文章于 2024-10-16 10:13:45 发布

阅读量90

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/qq_75277260/article/details/128360006

版权

本文详细探讨了Java中的静态成员变量、静态方法、单例模式、抽象类与接口的应用。讲解了静态变量与实例变量的区别，静态方法的访问规则，以及如何通过静态方法实现通用功能。同时，通过示例展示了静态代码块和实例代码块的执行顺序。此外，文章还介绍了饿汉单例和懒汉单例的实现方式，强调了单例模式确保类只有一个实例的重要性。最后，讨论了抽象类和接口的使用场景，以及接口中的默认方法、静态方法和私有方法的特性。

摘要由CSDN通过智能技术生成

有stastic修饰，与类一起加载，内存中只有一份，可以被访问。

变量：局部变量，成员变量。成员变量：分为静态成员变量和实例成员变量

常量public static final修饰的成员变量，命名规范全部使用大写，一定要初始化

静态成员变量：访问规则：建立用类名访问,类名.静态成员变量。

也可以通过对象名.静态成员变量(不推荐)

实例成员变量：与对象一起加载，每个对象中存在一份实力成员变量，可以通过：对象名.实例成员变量访问。
静态成员方法可以做一个通用功能，可以使多个类访问，访问：类名.方法名

package com.itqingdong.d1_static;

public class staticKey {
    //1.静态方法只能访问静态成员，不能访问实例成员
    //2.实例方法可以访问静态成员，
    private String name;//实例成员变量
    private int age;//实例成员变量
    private static int onlineUser=145;//静态成员变量
    //静态方法
    public static void test01(){
        //两种调用方法
        System.out.println(onlineUser);
        System.out.println(staticKey.onlineUser);//类名.静态成员变量
        //System.out.println(name);//报错，静态方法只能访问静态成员，不能直接访问实例成员
        //如：
        staticKey t=new staticKey();//创建一个对象
        System.out.println(t.name+t.age);//间接访问
    }
    private void run(){
        System.out.println(name+"很高兴！"+name+age+"岁了");
        System.out.println(onlineUser);
    }
    //静态方法中不能出现this关键字
    public static void test02(){
        //System.out.println(this);//报错
        //this代表当前方法
    }
    public static void main(String[] args) {
        //1.静态方法只能访问静态成员，不能直接访问实例成员
        //2.实例方法可以访问静态成员，也可以访问实例成员
         staticKey s =new staticKey();
         s.name="张三";
         s.age=10;
         s.run();

    }
}

方法：

package com.itqingdong.d1_static;

public class staticMethod {
    /**
     * 静态成员方法，有static修饰，归属于类，可以通过类名访问，也可以通过对象访问
     */
    public static int getMax(int a,int b){
        return a>b?a:b;//三元运算符
    }

    /**
     * 实例成员方法，无static修饰，归属于对象，只能通过对象访问，归属于对象
     */
    private String name;//实例成员变量，无static修饰，归属于对象
    public void study(){
        System.out.println(name+"在学习。");
    }

    public static void main(String[] args) {
        //通过类名来访问
        System.out.println(staticMethod.getMax(10, 20));
        //在同一个类中访问成员方法可以直接访问
        System.out.println(getMax(14, 25));


        staticMethod c =new staticMethod();
        c.name="张三";
        c.study();//通过对象来访问
        //调用静态方法不建议通过对象名
        System.out.println(c.getMax(10,70));

    }
}

package com.itqingdong.d1_static;

public class User {
    /**
     * 在线人数
     */
    public static int onlineUser=176;//静态成员变量
    /**
     * 实例成员变量无static修饰，属于每个变量，必须用对象名来访问
     */
    private String name;//实例成员变量
    private  int age;//实例成员变量

    public static void main(String[] args) {
     User c = new User();
     c.name="张三";
     c.age=11;
     //User.name="张三";  //  不能用类名来访问变量
     User c1=new User();
        System.out.println(c1.onlineUser);//不建议使用对象名来访问有static修饰的变量
        System.out.println(User.onlineUser);//建议使用类名来访问有static修饰的变量
        System.out.println(onlineUser);//同一个类中可以直接访问静态成员变量
       // System.out.println(name);//实例成员变量无static修饰，属于每个变量，必须用对象名来访问
    }
}

工具类：静态方法完成通用功能，一般把工具类的构造器私有化
代码块：类五大成分（成员变量，方法，构造器，代码块，内部类）

package com.itqingdong.d3_static;

public class CodeBlackDemo {
    public  CodeBlackDemo(){
        System.out.println("构造器被执行了=====");
    }
    /*
    实例代码块比构造器先执行
     */
    private String name;//实例成员变量
    {
        name="张三";//初始化实例资源，但意义不大，一般不这样干。
        System.out.println("实例代码块被执行了=====");
    }

    public static void main(String[] args) {
        CodeBlackDemo c=new CodeBlackDemo();
        System.out.println(c.name);
        CodeBlackDemo c2=new CodeBlackDemo();
        System.out.println(c2.name);
    }
}

静态代码块：static修饰,进行静态资源的初始化操作

static{}

实例代码块:

{}

package com.itqingdong.d3_static;
public class staticCodeBlock {
    /*
    构造代码块（实例代码块）{}
     */
    {
    }
    /*
     静态代码块,和类一起加载，可用于初始化静态资源
    */
    private static  String name;
    static {
        System.out.println("=========");
        name ="清冬";
    }
    public static void main(String[] args) {
        System.out.println(name);

    }
}

单例：保证一个类对外只能产生一个单例
饿汉单例：拿对象时，对象已经存在

package com.itqingdong.d4_SingleInstence;
/*
饿汉单例
 */
public class SingleInstence {
    /*
    饿汉单例是在获取对象前，对象就已经提前准备好了一个
    这个对象只能是一个所以定义静态成员变量
     */
    public static SingleInstence instence=new SingleInstence();
    /*
    构造器私有化
     */
    private SingleInstence(){

    }

}

package com.itqingdong.d4_SingleInstence;

public class Test01 {
    public static void main(String[] args) {
        //饿汉单例
        SingleInstence s1=SingleInstence.instence;
        SingleInstence s2=SingleInstence.instence;
        System.out.println(s1==s2);//判断两个对象的地址是否相同
    }
}

懒汉单例：拿对象时，创建一个对象

package com.itqingdong.d4_SingleInstence;

public class SingleInstance02 {
    /*
    定义一个静态成员变量储存一个对象，只运行一次。
     */
    private static SingleInstance02 a;
    /*

     */
    public static SingleInstance02 getInstance() {
        if (a == null) {
            a = new SingleInstance02();//为了只创建一个对象
        }
        return a;
    }
    /*
    私有化构造器，必须要进行的一步
     */
    private SingleInstance02(){

    }

}

一般构造器私有，定义为静态成员变量
继承：extends

类与类单继承

接口与接口多继承

类和接口多实现
顶级父类：objects
1.子类不能直接访问父类的私有成员

2.子类不能继承父类构造器

3.子类可以直接在子类访问父类静态成员

4.继承后成员变量方法的访问特点就近原则5.子类的全部构造器默认先访问父类的无参构造器，在执行子类自己的构造器

1.this.子类自己的成员变量

2.super.父类成员变量/父类成员方法

super（...），根据参数调父类的构造器

this(...)和super（...）都只能在第一行

方法重写@Override
保持名称与形参列表一致
私有静态方法不能重写，重写方法的权限>=被重写方法

包：导包：包名.类名
相同包下，内部可以互相访问

权限修饰符:public<protected<缺省<private

final修饰类，该类不能继承（该类是最终类）(工具类可以用)

修饰方法不能进行方法重写

修饰变量变量只能被赋值一次

宏替换把使用常量的地方全部替换成真实的字面量

枚举：信息标志和分类

抽象类可以修饰类，方法

package com.itqingdong.d1_angry;

/**
 *  抽象lei（不完整的设计图）
 */
public abstract class abstractDemo02 {
    /**
     * 抽象方法
     * 一个类中有 抽象方法则必须定义 抽象lei
     */
    public abstract void run();//无大括号

}

//一个类继承了抽象类则必须重写完这个抽象类的所有抽象方法，

//抽象类中不一定有抽象方法，但有抽象方法的类一定为抽象类

package com.itqingdong.d1_angry;

public class absstractTest02 extends abstractDemo02{
    //方法重写
    @Override
    public void run(){
        System.out.println(" ");
    }
}

接口：
接口写常量，抽象方法，由于接口体现了规范思想默认都是公开的，所以在代码层面，接口可以多继承
实现类就是实现接口的类

package com.itqingdong.d1_angry;
/*
接口可以多继承
 */
public interface InterfaceDemo1 extends InterfaceDemo333,InterfaceDemo2{
    String name="清冬";
    void run();
    public static final String name01="初行";
}

package com.itqingdong.d1_angry;

public interface InterfaceDemo333 {
    void eat();
}

package com.itqingdong.d1_angry;

public interface InterfaceDemo2 {
    void law();
}

package com.itqingdong.d1_angry;
//一个类实现了接口必须重写接口中的方法
public class InterfaceDemo01 implements InterfaceDemo1 {
    public static final String name="清冬";

    @Override
    public void run() {
        System.out.println("跑的很快！");
    }

    @Override
    public void law() {
        System.out.println("要遵守法律！");
    }

    @Override
    public void eat() {
        System.out.println("人们都要吃饭！");
    }
}

接口中的方法：

package com.itqingdong.d2_interface;

public interface People {

    /*
    默认方法（实例方法）
    --必须defult修饰。 默认用public修饰
    接口不能创建对象，只能过度到实现类由实现类的对象来调出。
     */
    default void run(){
        System.out.println("狗跑得贼快！");
        law();
//这里把law（）提到默认方法中来调用是因为私有方法只能在接口类中进行调用
    }
    /*
    静态方法
    必须有static 修饰默认用public修饰
    接口的静态方法，必须由接口名自己调用
     */
    public static void eat(){
        System.out.println("狗吃的贼多！");
        //law();报错
    }
    /*
    私有方法
    由private修饰,只能在接口类中进行调用
     */
    private void law(){
        System.out.println("遵守法律是我们自己的事。");
    }
}
//实现类
class PingPongMan implements People{

}
//测试类
class Test {
    public static void main(String[] args) {
        PingPongMan p = new PingPongMan();
        p.run();
        People.eat();
        //PingPongMan.law();报错
    }
}