Java学习第三十三天＜main语法＞＜代码块＞＜设计模式＞

main语法

package chapter10.D1类变量和类方法;
​
public class Main01 {
    private static String name="征途";
    private int n1=1000;
    private void cry(){
        System.out.println("main02方法");
    }
    public static void hi(){
        System.out.println("main01方法");
    }
    public static void main(String[] args) {
        //静态方法可访问本类静态成员
        System.out.println(name);
        hi();
        //静态方法不能调用本类非静态成员,只能创建对象
        new Main01().n1=10;
        new Main01().cry();
        System.out.println(new Main01().n1);
​
    }
}

package chapter10.D1类变量和类方法;
//传参数按 Main02>edit configuration>program auguements
public class Main02 {
    public static void main(String[] args) {
        for (int i = 0; i < args.length ; i++) {
            System.out.println("args["+i+"]="+args[i]);
        }
    }
}

代码块

package chapter10.D2代码块;
​
public class CodeBlock {
    public static void main(String[] args) {
        Movie xx = new Movie("你好");
        Movie yy = new Movie("阴天", 200);
    }
​
}
class Movie{
    private String name;
    private double price;
    private String director;
​
    //3个构造器构成重载，可以把相同语句放入代码块，如此不管调用哪个构造器（创建对象）都会调用代码块内容
    //代码块优先于构造器调用
    //以下是普通代码块，每创建一个对象就执行
    {
        System.out.println("方法");
        System.out.println("应用");
    }
    public Movie(String name) {
        System.out.println("(String name)代码被调用");
        this.name = name;
    }
​
    public Movie(String name, double price) {
        System.out.println("(String name, double price)构造器被调用");
        this.name = name;
        this.price = price;
    }
​
    public Movie(String name, double price, String director) {
        this.name = name;
        this.price = price;
        this.director = director;
    }
}

package chapter10.D2代码块;
​
import chapter07.D5多态.Detail.Animal;
​
//静态代码块随类的加载而执行，只执行一次
public class CodeBlockDetail {
    public static void main(String[] args) {
        //类被加载情况举例
        AA aa = new AA();//创建对象实例时会被调用
        BB bb = new BB();//创建子类对象，父类会优先被加载
        System.out.println(Cat.n1);//使用类静态成员时被调用，但会优先调用父类
        System.out.println(Cat.n2);//只执行父类
        //普通代码块只在创建对象时执行，创一次调用一次
​
​
    }
}
//静态代码块
class AA{
    static {
        System.out.println("AA的静态代码块1被执行....");
    }
}
class BB extends AA{
    static {
        System.out.println("BB 的静态代码块1被执行");
    }
}
class Animal2{
    public static int n1=99;
    public static int n2=9;
    static {
        System.out.println("Animal2类的代码块被执行");
    }
}
class Cat extends Animal2 {
    public static int n1=999;//静态属性
    static {
        System.out.println("Cat的静态代码块被执行");
    }
    {
        System.out.println("普通代码块执行");
    }
}

package chapter10.D2代码块;
​
public class CodeBlockDetail02 {
    public static void main(String[] args) {
        A a = new A();//1.getN1() 2.n1 3.静态代码块  顺序可反 4.普通代码块 5.getN2 6.n2 7构造器
    }
}
class A{
    public A() {
        System.out.println("构造器执行");
    }
​
    //静态代码块和静态属性初始化优先级一样，按顺序执行
    private static  int n1=getN1();//静态属性初始化
​
    {
        System.out.println("A 普通代码块01");
    }
    private int n2=getN2();
    static {//静态代码块
        System.out.println("A 静态代码块01");
    }
​
    public int getN2(){
        System.out.println("getN2被调用");
        return 50;
        }
        public static int getN1(){
        System.out.println("getN1被调用...");
        return 100;
    }
​
}

package chapter10.D2代码块;
​
public class CodeBlockDetail03 {
    public static void main(String[] args) {
        BBB bbb = new BBB();
​
    }
}
class AAA{
    public AAA(){
        System.out.println("AAA构造器被调用");
    }
}
class BBB extends AAA{
    {
        System.out.println("BBB普通代码块");
    }
    public BBB(){
        //super
        //普通代码块
        System.out.println("BBB构造器被调用");
    }
}

package chapter10.D2代码块;
//父静态（代码块、属性），子静，父普（代码块、属性），父构，子普，子构
public class CodeBlockDetail04 {
    public static void main(String[] args) {
        B02 b02 = new B02();//1类的加载 2创建对象
        new C02();
    }
}
class A02{
    private static int n1=getVal01();
    static {
        System.out.println("A02静态代码块");//2
    }
    {
        System.out.println("A02普通代码块");//5
    }
    public int n3=getVal02();
    public static int getVal01(){
        System.out.println("getVal01");//1
        return 10;
    }
    public int getVal02(){
        System.out.println("getVal02");///6
        return 10;
    }
​
    public A02() {//类加载完，创建对象，执行隐藏语句，转到5
        //super
        //普通代码块，属性
        System.out.println("A02无参构造器");//7
    }
}
class B02 extends A02{
    private static int n3=getVal03();
    static {
        System.out.println("B02静态代码块");//4
    }
    public int n5=getVal04();
    {
        System.out.println("B02普通代码块");//9
    }
    public static int getVal03(){
        System.out.println("getVal03");//3
        return 10;
    }
    public  int getVal04(){
        System.out.println("getVal04");//8
        return 10;
    }
​
    public B02() {//跳转super
        System.out.println("B02无参构造器执行");//10
    }
}
//静态代码块只能调用静态成员（属性，方法），普通代码块可以调用任意成员
class C02{
    private int n1=100;
    private static int n2=200;
    private void m1(){
​
    }
    private static void m2(){
​
    }
    static {
        System.out.println(n2);//静态代码块只能调用静态成员
        m2();
    }
    {
        System.out.println(n1);//普通代码块可以调用所有
        System.out.println(n2);
        m1();
        m2();
    }
}

设计模式

单例模式懒汉式

package chapter10.D3设计模式.单例模式懒汉式;
//懒汉式单例模式，只有当用户使用getInstance时候才返回对象，再次调用时仍然返回上次对象，保证对象单例
public class single02 {
    public static void main(String[] args) {
        System.out.println(Cat.n1);//加载类同时加载静态成员，但对象没创建
        Cat instance = Cat.getInstance();//这时候才创建
        System.out.println(instance);
        Cat instance1 = Cat.getInstance();//不会再创建新的
        System.out.println(instance1);
​
    }
}
​
//程序运行中只能创一个Cat对象，单例模式
class Cat{
    private String name;
    public static int n1=999;
​
    private Cat(String name) {
        System.out.println("构造器被调用");
        this.name = name;
    }
    private static Cat cat;//定义一个static 静态属性对象，不创建对象
    public static Cat getInstance(){//有线程安全问题
        if (cat==null){//若没创建对象
            cat=new Cat("小可爱");
        }
        return cat;
    }
​
    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                '}';
    }
}

单例模式饿汉式

package chapter10.D3设计模式.单例模式饿汉式;
​
public class Single {
    public static void main(String[] args) {
        //GirFriend xh = new GirFriend("小红");避免多个对象
        GirFriend gf = GirFriend.getGf();//拿到对象，再拿一次也是同一个对象
        System.out.println(gf);
​
        System.out.println(GirFriend.n1);//会加载类，加载静态成员，饿汉式可能创建了对象，但没使用
​
    }
}
class GirFriend{
    private String name;
    public static int n1=100;
​
     //保证只能创建一个GirFriend对象 1.构造器私有化（防止类外部创建） 2.内部类中创建对象（static） 3.提供公共static方法，返回gf对象
    private  GirFriend(String name) {
​
        this.name = name;
    }
    private  static GirFriend gf =new GirFriend("小红");//若不加static，则无法在静态方法中使用，方法不静态，则又要创建对象调用
    public static GirFriend getGf(){
        return gf;
    }
​
    @Override
    public String toString() {
        return "GirFriend{" +
                "name='" + name + '\'' +
                '}';
    }
}