publicclassUser {
// static修饰的成员变量（静态成员变量），不会放到某个对象中，在整个内存中只有一份，可以被共享publicstaticintonlineNumber=100;
// 无static修饰的实例成员变量（实例成员变量）：属于某一个对象privateStringname;
privateintage;
publicstaticvoidmain(String[] args) {
// 访问静态成员变量推荐方式：类名.静态成员变量System.out.println(User.onlineNumber); // 100// 访问实例成员变量：对象名.成员变量//        System.out.println(User.name); // 报错，只能通过某个对象来访问实例成员变量，不能通过类直接访问Useruser=newUser();
System.out.println(user.name="张三"); // 张三System.out.println(user.age=20); // 20// 静态成员变量在整个内存中只有一份，可以被共享User.onlineNumber++;
System.out.println(User.onlineNumber); // 101// 在同一个类中访问静态成员变量可以省略类名，直接访问System.out.println(onlineNumber); // 101    }

publicclassStudent {
privateStringname;
privatestaticintage;
// 静态成员方法   用static修饰，归属于类，用类名或对象名都可以访问publicstaticintgetMax(intage1, intage2) {
returnage1>=age2?age1 : age2;
    }
// 实例成员方法   无static修饰，属于对象，只能用对象名访问publicvoidstudy() {
System.out.println(name+"好好学习，天天向上！");
    }
publicstaticvoidmain(String[] args) {
//        System.out.println(name); // 报错，name属于实例成员变量，只能通过对象访问，没有对象不能访问System.out.println(Student.age); // 0   age属于静态成员变量，可以通过类名访问（同一个类中类名可以省略），也可以通过对象访问// 静态成员方法的调用：类名.静态成员方法System.out.println(Student.getMax(10, 6)); // 10// 也可以用：对象.静态成员方法   来调用,不建议用此种方法Studentstu1=newStudent();
System.out.println(stu1.getMax(5, 6)); // 6// 注：同一个类中，静态成员方法可以不加类名或对象名，直接调用System.out.println(getMax(100, 80)); // 100// 实例成员方法的调用：对象.实例成员方法//        study();// 报错，study()属于实例成员方法，只能通过对象访问，没有对象不能访问Studentstu2=newStudent();
stu2.name="张三";
stu2.study(); // 张三好好学习，天天向上！    }
}

publicclassTest {
/*静态成员*/publicstaticintonlineNumber=10;
publicstaticvoidgo() {
System.out.println("***go***");
    }
/*实例成员*/publicStringname;
publicvoidrun() {
System.out.println(name+"跑得快！");
    }
// 1.静态方法只能直接访问静态的成员(变量、方法)，不可以直接访问实例成员。publicstaticvoidtest1() {
System.out.println(Test.onlineNumber);
Test.go();
//        System.out.println(name); // 报错//        Test.run(); // 报错    }
// 2.实例方法可以访问静态的成员，也可以访问实例成员。publicvoidtest2() {
System.out.println(Test.onlineNumber);
Test.go();
System.out.println(name);
run();
    }
// 3.静态方法中不可以出现this关键字。publicstaticvoidtest3() {
//        System.out.println(this); // 报错，this代表当前对象的地址，没有对象不能使用this    }
publicvoidtest3_2() {
System.out.println(this); // 调用实例方法时需要先实例化对象，有对象可以使用this    }
}

publicclassArraysUtil {
// 将构造器私有，拒绝创建数组工具类对象privateArraysUtil() {
    }
/*工具方法：静态方法*//*** create by: 全聚德在逃烤鸭、* description: 返回整数数组的内容* create time: 2022/4/14 0014 12:49** @param arr* @return java.lang.String*/publicstaticStringarrayToString(int[] arr) {
// 校验if (arr==null) {
returnnull;
        }
// 拼接内容并返回Stringresult="[";
for (inti=0; i<arr.length; i++) {
result+= (i==arr.length-1?arr[i] : arr[i] +",");
        }
result+="]";
returnresult;
    }
}

publicclassTestDemo2 {
publicstaticvoidmain(String[] args) {
int[] arr1=null;
System.out.println(ArraysUtil.arrayToString(arr1)); // nullint[] arr2= {};
System.out.println(ArraysUtil.arrayToString(arr2)); // []int[] arr3= {10, 20, 33};
System.out.println(arr3); // [I@1540e19d    堆内存中new出来的数组的地址System.out.println(ArraysUtil.arrayToString(arr3)); // [10,20,33]    }
}

publicclassStaticDemo1 {
publicstaticintonlineNumber;
/***  静态代码块   由static修饰，随着类的加载而加载，并且自动触发、只执行一次*  作用：用于初始化静态资源*/static {
System.out.println("-----静态代码块被执行了-----");
onlineNumber=150;
    }
publicstaticvoidmain(String[] args) {
System.out.println("-----main方法执行了-----");
System.out.println(onlineNumber);
    }
}

publicclassStaticTest3 {
// 系统只需要一副牌，因此定义一个静态集合(相当于定义静态成员变量，实例化相当于赋初值），这样集合只会在加载类的时候加载一个publicstaticArrayList<String>cardList=newArrayList<>();
// 在程序真正运行（main方法执行）之前，在集合中存储54张牌static {
// 存放扑克牌// 存储非大小王的52张牌// 存储点数   点数类型确定、个数确定——使用数组String[] sizes= {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
// 存储花色 花色类型确定、个数确定——使用数组String[] colors= {"♥", "♦", "♠", "♣"};
// 遍历点数、花色，将扑克牌依次组合起来for (inti=0; i<sizes.length; i++) {
for (intj=0; j<colors.length; j++) {
Stringcard=colors[j] +sizes[i]; // 点数、花色两两依次组合cardList.add(card); // 将组合好的扑克牌加入到数组中            }
        }
// 存储大小王cardList.add("joker");
cardList.add("Joker");
    }
publicstaticvoidmain(String[] args) {
System.out.println("扑克牌:"+StaticTest3.cardList);
    }
}

publicclassSingleInstance {
/*** 1.私有化构造器*/privateSingleInstance() {
    }
/*** 2.饿汉单例在获取对象前，提前准备好对象* 只能是一个对象，所以用static修饰*/publicstaticSingleInstancesingleInstance=newSingleInstance();
}

publicclassTest1 {
publicstaticvoidmain(String[] args) {
SingleInstancesingleInstance1=SingleInstance.singleInstance;
SingleInstancesingleInstance2=SingleInstance.singleInstance;
System.out.println(singleInstance1==singleInstance2); // true 说明两个SingleInstance类型的变量存储的是同一个对象的地址值    }
}

publicclassSingleInstance2 {
/*** 2.定义一个静态成员变量负责存储一个对象* 因为是单例模式，只加载一次，所以用静态*//*存储对象地址的变量需要进行私有化，仅允许通过方法的方式得到该变量存储的对象的地址值，不允许通过对象.变量名的方式直接获取因为在懒汉单例模式，对象并不是在类加载时同步创建，而是在使用的时候再创建，若此时还没有使用，直接获取，结果为null*/privatestaticSingleInstance2singleInstance2;
/*** 1.私有化构造器*/privateSingleInstance2() {
    }
/*** 提供一个方法，对外返回单例对象*/publicstaticSingleInstance2getInstance() {
// return singleInstance2 = new SingleInstance2(); // 错误的方式，此种方式，每调用一次该方法，就会new一个新的SingleInstance2对象返回，不是单例模式// 判断静态变量是否存在，即是否new过SingleInstance2对象/*** 若变量不存在，说明没有new过，此时new一个SingleInstance2对象并返回；若变量存在，说明之前new过，单例模式不允许实例化两个对象，此时直接将singleInstance2变量返回*/if (singleInstance2==null) {
returnsingleInstance2=newSingleInstance2();
        }
returnsingleInstance2;
    }
}

publicclassTest2 {
publicstaticvoidmain(String[] args) {
SingleInstance2singleInstance2=SingleInstance2.getInstance();
SingleInstance2singleInstance2_2=SingleInstance2.getInstance();
System.out.println(singleInstance2==singleInstance2_2); // true   说明两个SingleInstance2类型的变量存储的是同一个对象的地址值    }
}

publicclassTest {
publicstaticvoidmain(String[] args) {
Dogdog=newDog();
/*就近原则代码中涉及的变量查询规则顺序：①先在子类的涉及该变量的局部范围中查询，找到则调用并结束②若没找到再去子类的成员范围中查询，找到则调用并结束③若没找到再去上一级父类的成员范围中查询，找到则调用并结束④若没找到则依步骤③类推，直到找到，调用并结束或查询完继承链均没找到，报错并结束代码中涉及的方法查询规则顺序：①先在子类的成员范围中查询，找到则调用并结束②若没找到再去上一级父类的成员范围中查询，找到则调用并结束③若没找到则依步骤③类推，直到找到，调用并结束或查询完继承链均没找到，报错并结束*/dog.lookDoor(); // 看门狗dog.run(); // 狗跑得快  若将Dog类中的run()方法注释掉，打印结果为"动物可以跑"dog.showName(); // 名称是大黄    若将Dog类中showName()方法中的的String name = "大黄";行注释掉，打印结果为"名称是狗"//                             若将Dog类中的public String name = "狗";行注释掉，打印结果为"名称是动物"dog.testsuper(); // 狗跑得快//                  动物可以跑    }
}
classAnimal {
publicStringname="动物";
publicvoidrun() {
System.out.println("动物可以跑");
    }
}
classDogextendsAnimal {
publicStringname="狗";
publicvoidlookDoor() {
System.out.println("看门狗");
    }
publicvoidshowName() {
Stringname="大黄";
System.out.println("名称是"+name); // 访问当前方法中定义的name//        System.out.println("名称是" + this.name); // 访问当前对象的成员变量name//        System.out.println("名称是" + super.name); // 访问当前类的父类的成员变量name    }
publicvoidrun() {
System.out.println("狗跑得快");
    }
publicvoidtestsuper() {
run(); // 默认优先调用当前类中的成员方法（两个实例方法可以直接互相调用）super.run(); // 调用父类中的成员方法    }
}

publicclassTest {
publicstaticvoidmain(String[] args) {
NewPhonenewPhone=newNewPhone();
newPhone.call();
newPhone.sendMsg();
    }
}
classPhone {
publicvoidcall() {
System.out.println("打电话");
    }
publicvoidsendMsg() {
System.out.println("发信息");
    }
}
classNewPhoneextendsPhone {
// 重写父类方法publicvoidcall() {
super.call(); // 使用父类的方法// 在父类方法的基础上添加一些新功能System.out.println("视频通话");
    }
publicvoidsendMsg() {
super.sendMsg();
System.out.println("发送图片");
    }
}

publicclassAnimal {
publicAnimal() {
System.out.println("Animal无参构造器被执行了");
    }
publicAnimal(intage) {
System.out.println("Animal有参构造器被执行了");
    }
}

publicclassDogextendsAnimal {
publicDog() {
//        super(); // 默认存在，写不写都可System.out.println("Dog无参构造器被执行了");
    }
publicDog(Stringname) {
System.out.println("Dog有参构造器被执行了");
    }
publicDog(intage) {
// 在子类构造器中添加super(参数)来选择执行父类的有参构造器super(2); // 添加super()语句，必须写在子类构造器的第一行，否则报错System.out.println("Dog有参构造器被执行了");
    }
}

publicclassTest {
publicstaticvoidmain(String[] args) {
// 子类执行无参构造器之前，默认先执行父类的无参构造器Dogdog1=newDog();
System.out.println("-----------");
// 子类执行有参构造器之前，默认先执行父类的无参构造器Dogdog2=newDog("大黄");
// 在子类构造器中添加super(参数)来选择执行父类的有参构造器System.out.println("-----------");
Dogdog3=newDog(5);
    }
}

publicclassStudent {
privateStringname;
privateStringschoolName;
publicStudent() {
    }
/*若用户未填写学校名称字段，则默认这个对象的学校名称字段为"光明小学"*/publicStudent(Stringname) {
// 访问本类其他构造器，将默认值传入this(name, "光明小学");
    }
publicStudent(Stringname, StringschoolName) {
this.name=name;
this.schoolName=schoolName;
    }
// setter、getter}

publicclassTest {
publicstaticvoidmain(String[] args) {
Studentstu1=newStudent("张三", "实验小学");
System.out.println(stu1.getName());
System.out.println(stu1.getSchoolName());
System.out.println("-----------");
Studentstu2=newStudent("李四");
System.out.println(stu2.getName());
System.out.println(stu2.getSchoolName());
    }
}