JavaSE

switch(表达式){
  case 值1:
    执行代码...;
    break;
  case 值2:
    执行代码...;
    break;
  ...
  case 值n-1:
    执行代码...;
    braek;
  default:
    执行代码n;
}

标签名: 
for (初始化; 条件; 迭代) {
    // 外层循环
    for (初始化; 条件; 迭代) {
        // 内层循环
        if (某种条件) {
            break 标签名; // 直接跳出到标签指定的循环之后
        }
    }
}
// 跳转到这里

public void print(String name){//this关键字解决变量冲突问题
    System.out.println(name+this.name);//this.name拿到的是对象变量(成员变量)name,而不是局部变量name
}

public class StaticAbout {//工具类
    //工具类没有创建对象的必要性，建议将工具类的构造器私有化。
    private StaticAbout() {
    }
    public static String getCode(int n) {//静态方法与工具类
        String code = "";
        for (int i = 0; i < n; i++) {
            int type = (int) (Math.random() * 3);//0-9 1-26 2-26
            switch (type) {
                case 0:
                    code += (int) (Math.random() * 10);
                    break;
                case 1:
                    code += (char) (Math.random() * 26 + 'a');//得到小写字母的区间
                    break;
                case 2:
                    code += (char) (Math.random() * 26 + 'A');
            }
        }
        return code;
    }
}

public class Attention{
    public static int count=100;//静态变量
    public static void print(){//静态方法
        System.out.println("Hello World!");
    }
    public String name;//实例变量，属于对象
    public void prints(){//实例方法，属于对象
    }
    public static void main(String[] args) {

    }
    //（1）、静态方法中可直接访问静态成员，不可直接访问实例成员。
    public static void printTest1(){
        System.out.println(count);
        print();
        //System.out.println(name);//报错
        //prints();//报错
        //System.out.println(this);//报错，this代表的只能是对象
        System.out.println(Attention.count);
    }
    //（2）、实例方法中即可直接访问静态成员，也可直接访问实例成员。
    public void printTest2(){
        System.out.println(count);
        print();
        System.out.println(name);
        prints();
        System.out.println(this);//实例方法中，this代表的是当前对象
    }
}

public class Father {
    private void privateMethod() {//二、2、权限修饰符之私有方法
        System.out.println("private method");
    }

    void defaultMethod() {//二、2、权限修饰符之缺省方法
        System.out.println("default method");
    }

    protected void protectedMethod() {//二、2、权限修饰符之受保护方法
        System.out.println("protected method");
    }

    public void publicMethod() {//二、2、权限修饰符之公共方法
        System.out.println("public method");
    }
    public static void main(String[] args) {//本类中可以调用的所有方法
        Father father = new Father();
        father.privateMethod();
        father.defaultMethod();
        father.protectedMethod();
        father.publicMethod();//所有类都可以调用public方法
    }
}
//以下为同一包的子类
class SonA extends Father {
    public void test() {
        //privateMethod();//子类中不可以访问父类的私有方法
        defaultMethod();//子类中可以访问父类的缺省方法
        protectedMethod();//子类中可以访问父类的受保护方法
        publicMethod();//子类中可以访问父类的公共方法
    }
}
//以下为不同包的子类
class SonC extends Father {
    public void test() {
        //privateMethod();//子类中不可以访问父类的私有方法
        //defaultMethod();//不同包的子类中可以访问父类的缺省方法
        protectedMethod();//不同包的子类中可以访问父类的受保护方法
        publicMethod();//不同包的子类中可以访问父类的公共方法
    }
}
//以下为不同包的非子类
class main {
    public static void main(String[] args) {
        Father father = new Father();
        //father.privateMethod();
        //father.defaultMethod();
        //father.protectedMethod();
        father.publicMethod();//其他包中，只能访问public方法
    }
}

public class TestFeature{//测试类
//二、3、继承的特点
    public static void main(String[] args) {
        zilei zi=new zilei();
        zi.test();
    }
}
class fulei{
    String name="FUlei";
    public void run(){
        System.out.println("fuleiRun");
    }
}
class zilei extends fulei{
    String name="ZiLei";
    public void run(){
        System.out.println("zileiRun");
    }
    public void test(){
        String name="ZiLeiTEST";
        System.out.println(name);//test的name
        System.out.println(this.name);//zilei的name
        System.out.println(super.name);//fulei的name
        run();//zilei的run优先级更高
        this.run();//zilei的run
        super.run();//fulei的run
    }
}

public class TestOverride {
    public static void main(String[] args) {//二、4、方法重写
         animal a=new cat();
//用父类申明对象，利用多态性和向上转型的概念，以实现更加灵活和可扩展的程序设计，降低代码的耦合性
         a.eat();
         cat b=new cat();
         b.eat();
    }
}
class animal{
    public void eat(){System.out.println("animal eat");}
}
class cat extends animal{
    @Override//方法重写的校验注解（标志），要求重写的方法与父类方法签名一致，否则编译报错，可读性好
    public void eat(){System.out.println("cat eat!!!");}
}

public class TestOverride {
    public static void main(String[] args) {
         animal a=new animal();
         System.out.println(a);
//若没重写toString方法，则返回：com.rasion.extendANDpolymorphism.extend.cat@4e50df2e
         System.out.println(a.toString());
        //我们直接输出对象，会默认调用Object的toString方法，返回对象的地址信息
        //故我们可以重写toString方法，返回我们想要的信息
    }
}
class animal{
    private String name;
    @Override
    public String toString() {//重写toString方法,返回我们想要的信息
        return "animal{" +
                "name='" + name + '\'' +
                '}';
    }
}

public class User{
    private String name;
    private int age;
    private String school;
    //...此处省略get、set方法toString方法
    public User(String name, int age) {
        this(name, age, "黑马");//调用本类其他构造器，以实现填写默认信息
    }
    public User(String name, int age, String school) {
        this.name = name;
        this.age = age;
        this.school=school;
    }
}

 people p1=new student();//对象多态
 p1.run();//行为多态
 people p2=new teacher();//对象多态
 p2.run();//方法：编译看左边，运行看右边
        
 System.out.println(p2.name);//成员变量：编译看左边，运行也看左边

public class TestPolymorphism {
    public static void main(String[] args) {
        people p1=new student();//多态调用不了子类的独有功能
        people p2=new teacher();
        show(p1);
        show(p2);
        System.out.println(p1.name);//成员变量：编译看左边，运行也看左边
    }
    public static void show(people p) {
        //父类类型作为参数，可以接收一切子类变量
        System.out.println("=====+++=====");
        p.run();//调用方法：编译看左边，运行看右边
    }
}

public class TestPolymorphism {
    public static void main(String[] args) {
        people p1=new student();
        people p2=new teacher();
        student s=(student)p1;//强制类型转换
        //teacher t=(teacher)p1;//转换错误，因为p1是student类型
        //编译阶段有类型强转不会报错，运行阶段会报错
        show(p1);
        show(p2);
    }
    public static void show(people p) {
        if(p instanceof teacher) {//判断类型，一般会在方法中写，来判断p是否为teacher类型
            teacher t=(teacher)p;
            ...//调用teacher的独有功能
        }else if(p instanceof student) {
            student s=(student)p;
            ...//调用student的独有功能
        }
    }
}

public class Constant {//常量包
    public static final String NAME = "rasion";
}

public class A {//饿汉式单例类：拿对象的时候对象早已生成，无论是用不用，都会创建。
    private A(){}//1、私有化构造器
    private static A a=new A();//2、实例化私有静态变量
    //当类被加载时，静态变量a会被初始化，此时类的私有构造函数会被调用。这时候，单例类的唯一实例就被创建出来了。
    public static A getObject(){
        return a;
    }//3、定义一个类方法返回对象
}

public class B {//懒汉式单例类：拿对象的时候才创建，真正需要对象时才开始创建。
    private B(){}//1、私有化构造器
    private static B b;//2、定义一个类变量用于存储对象
    public static B getInstance(){//提供一个类方法返回类的唯一对象
        if(b==null){
           //第一次拿对象时，会创建对象，给静态变量b记住。
           b=new B();
        }
        return b;
    }
}

public enum A {//枚举类
    X,Y,Z;//枚举类第一行只能罗列一些名称，这些名称都为常量，并且每个常量会记住枚举类的一个对象
}

Compiled from "A.java"//对A.java的反编译
public final class A extends java.lang.Enum<A>{//枚举类继承了Enum
    public static final A X=new A();//枚举类第一行只能罗列一些名称，这些名称都为常量，并且每个常量会记住枚举类的一个对象
    public static final A Y=new A();//如果只有一个Y的话，可以被视为单例类。
    public static final A Z=new A();
    //枚举类的构造器都是私有的（写不写都只能是私有的），因此，枚举类对外不能创建对象。
    public static A[] values();//返回枚举类的所有实例
    public static A valueOf(java.lang.String var0);//返回指定名称的枚举实例
}

public abstract class A {//抽象的本质是不能有对象，抽象类的基本作用就是被继承
    private String name;//抽象类有成员变量
    public A(){System.out.println("抽象类A的构造方法");}//抽象类有构造方法
    public void show(){System.out.println("抽象类A的show方法");}//抽象类的方法可以有方法体
//抽象方法，抽象类中可以有没有抽象方法，抽象方法没有方法体，只有方法声明，子类必须重写抽象方法
    public abstract void show();//抽象类的抽象方法不能写方法体
}

public abstract class fu {//父类抽象类
    public final void show(){//模板方法不能被重写
        System.out.println("模板方法");//子类共同的部分
        show1();//子类不同的部分
    }
    public abstract void show1();//抽象方法，子类一定要重写，不然就报错，这样做是最佳实现
}
public class A extends fu {//子类
    @Override
    public void show1(){System.out.println("A show1方法");}
}
public class B extends fu {//子类
    @Override
    public void show1(){System.out.println("B show1方法");}
}

public interface A {//接口不能创建对象，只能被实现
//JDK-8之前，接口只能定义常量和抽象方法，不能定义具体方法。
//1、常量：接口中的常量默认是public static final的，所以可以省略。
    String NAME="rasion";

    //2、抽象方法：接口中的抽象方法默认是public abstract的，所以可以省略。
//    public abstract void show();
    void show();
}
public class C implements A,B {//实现接口的类，可以实现多个接口
    @Override
    public void show() {
        System.out.println("C实现A\B接口的show方法");
    }
}

public class test {
    public static void main(){
//        Driver d=new Teacher();//做接口解耦合，可以不改变自己本来的代码
        Driver d=new Student();
        Cook c=new Student();
    }
}
public interface Driver {}
public interface Cook {}
class people{}//抽象类
class Teacher extends people implements Driver,Cook{}//实现多个接口，用逗号隔开
class Student extends people implements Driver,Cook{}

//jdk-8之后的三种方法
    //a、默认方法，一定要加default修饰符，默认会用public修饰，用接口的实现类对象调用
    default void defaultMethod(){
        System.out.println("defaultMethod");
        privateMethod();
    }

    //b、静态方法，一定要加static修饰符，默认会用public修饰，只能用当前接口名来调用
    static void staticMethod(){//静态方法
        System.out.println("staticMethod");
    }

    //c、私有方法，一定要加private修饰符，默认会用private修饰，用接口中的其他实例方法调用
    private void privateMethod(){//私有方法
        System.out.println("privateMethod");
    }

public class codeBlock {
    public static String NAME;
    public static String[] CARD=new String[54];//初始化数组
    static {//静态代码块，有static修饰,属于类，与类一起优先加载，自动执行一次
        System.out.println("static block");
        NAME="rasion";
        CARD[0]="A";//静态数组只需要初始化一次，就可以在静态代码块中初始化
        CARD[1]="2";
        CARD[2]="3";
    }
    {//实例代码块，没有static修饰，属于对象，与对象一起加载，对象加载几次，就会执行几次
        System.out.println("non-static block");
    }
    public static void main(String[] args) {
        System.out.println("hello main");
        System.out.println(NAME);
        System.out.println(Arrays.toString(CARD));//打印数组

        codeBlock cb=new codeBlock();//创建对象时，会执行实例代码块
        new codeBlock();
        new codeBlock();
        System.out.println(cb);
    }
}

public class main {
    public static void main(String[] args) {
        // 创建成员内部类对象格式：外部类名.内部类名 对象名= new 外部类名().new 内部类名();
        OuterClass.InnerClass innerClass = new OuterClass().new InnerClass();
        innerClass.print();//内部类对象调用内部类方法
    }
}
public class OuterClass {
    //成员内部类:无static修饰，属于外部类的对象持有的
    public class InnerClass{//类有的属性，方法内部类都能有
        private String num="InnerThis";
        public void print(){
            System.out.println("===innerMethod===");
            outerPrint();
            String num="-innerPrint-";
            System.out.println(num);
            System.out.println(this.num);//内部类对象
            System.out.println(OuterClass.this.num);//外部类对象

            OuterClass oc=new OuterClass();//创建外部类对象
            System.out.println(oc.num);
            run();
        }
    }

    //内部类可以访问外部类的静态成员
    public static void outerPrint(){//外部类静态方法
        System.out.println("OuterClass static print");
    }//静态内部类，属于外部类，外部类可以访问
    private String num="OuterThis";//外部类成员变量
    public void run(){}
}

public class main {
    public static void main(String[] args) {
        StaticInnerClass.InnerClass innerClass=new StaticInnerClass.InnerClass();//静态内部类对象
        innerClass.print();
    }
}
public class StaticInnerClass {
    public static class InnerClass{
        private String NAME="inner rasion";
        public void print() {
            System.out.println("StaticInnerClass print");
            //静态内部类可以直接访问外部类的静态成员
            System.out.println("StaticInnerClass NAME:"+StaticInnerClass.NAME);
            //静态内部类不可以直接访问外部类的实例成员
//            System.out.println("StaticInnerClass age:"+age);
            //静态内部类可以间接访问外部类的局部变量
            StaticInnerClass staticInnerClass=new StaticInnerClass();
            System.out.println("StaticInnerClass age:"+staticInnerClass.age);
        }
    }

    public static String NAME="outer rasion";//外部类的静态成员
    public int age=18;//外部类的实例成员，属于外部类对象的
}

public class AnonymityInnerClass {
    public static void main(String[] args) {
    //匿名内部类有名字：外部类名$编号.class
    //匿名内部类本质是一个子类，同时立即创建一个子类对象
        Animal cat=new Animal(){
            @Override
            public void run() {System.out.println("cat run");}
        };//匿名内部类，同cat类，即是一个子类又是一个子类对象
//        Animal cat=() -> System.out.println("cat run");//Lambda简化
        cat.run();
        print(cat);
        
        print(new Animal() {
            @Override
            public void run() {System.out.println("inner cat run");}
        });//同上print(cat);一样功能
    }
    public static void print(Animal animal){
        System.out.println("start==");
        animal.run();//匿名类对象回调，由于匿名类相当于子类，所以可以调用子类的方法
    }
}

interface Animal{
    public abstract void run();
}
//class cat extends Animal{
//    @Override
//    public void run() {
//        System.out.println("cat run");
//    }
/