一、JavaBase,我写的这些你知道吗?

几个变量的区别懂?

局部变量（顾名思义只能在一个方法里面使用的变量）

实例变量 （必须通过实例一个对象（new一个对象），用对象.变量属性）

类变量（用static修饰的变量，可以直接获取）

常量 （不可更改的变量）

代码一看便知

public class Test {

    String name;
    static int age;
    // 常量修饰的变量一般全大写--->一种规范 因为是不可变的  必咻初始化值
    final static double SALARY=100.00;
    public static void main(String[] args) {
        //局部变量 -->必须初始化值
        boolean flag=true;
        System.out.println(flag);

        //实例变量-->初始化默认值
        Test test = new Test();
        System.out.println(test.name);

        //类变量-->初始化默认值
        System.out.println(age);

        System.out.println(SALARY);
    }
}

关于运算 Math会用?

幂运算利用Math工具类

//表示2的3次方  返回的数据类型是double 
double pow = Math.pow(2, 3);
System.out.println(pow);

字符串连接问题

   public static void main(String[] args) {
        //字符串拼接问题
        int a=13;
        int b=14;
        System.out.println(a+b+"");//27--->在字符之前是运算
        System.out.println(""+a+b);//1314--->在字符之后是拼接
    }

可变参数是啥?

一个方法只能有一个可变参数，且必须在方法的最后一个参数，任何普通的参数必须在它之前声明

     public static void main(String[] args) {
        Test test = new Test();
        test.test("小黑猪",1,2,3,4,5);
        System.out.println("--------------------");
        //可变参数本质就是数组
        test.test("小黑猪",new int[]{1,22,133});
        System.out.println("--------------------");
        test.test("小黑猪");
    }


    public void test(String str,int... x){
        System.out.println(str);
        if (x.length==0){
            System.out.println("no parameter");
        }
        for (int i = 0; i < x.length; i++) {
            System.out.println(x[i]);
        }
    }

supper、this注意啥啊

supper：

1. 调用父类的构造方法必须在构造方法的第一行

2. 必须出现在子类的方法中或者构造方法中

3. supper和this不能同时调用构造方法

4. 构造方法：

   ​ this();本类的方法

   ​ supper();父类的方法

public class Person {
    protected String name;

//    public Person() {
//        System.out.println("我是所有的父类......");
//    }

    public Person(String name) {
        System.out.println(name+"说我是所有的父类......");
    }
}

public class Singer extends Person {
    private String name;

//    public Singer() {
//        //默认调用父类的无参构造方法
//        //自行调用时必须放在方法的第一行
        super();
//        System.out.println("I am a singer!");
//    }

    /*
        当父类只有只有有参构造方法时,必须在子类中实现super(参数)的调用 否则报错
     */
    public Singer(String name) {
        super(name);
        System.out.println(name + " is a singer!");
        this.name = name;
    }
}

public class Test {
    
    public static void main(String[] args) {
//        Singer singer = new Singer();
        Singer singer = new Singer("小猪佩奇");
    }

}

instanceof怎么用捏?

instanceof用于应用类之间的比较，如果两个没有关系的类进行比较，编译不通过

有Person和Singer两个自定义的类 随意啦!!

    public static void main(String[] args) {

        /*
        obj->person->singer
        obj->person->dancer
        obj->string
        obj是万类之源
        
        instanceof用于应用类之间的比较，如果两个没有关系的类进行比较，编译不通过
         */
        Object obj=new Singer();
        System.out.println(obj instanceof Object);//true
        System.out.println(obj instanceof Person);//true
        System.out.println(obj instanceof Singer);//true
        System.out.println(obj instanceof Dancer);//false
        System.out.println(obj instanceof String);//false

        System.out.println("------------------------");

        Person person=new Singer();
        System.out.println(person instanceof Object);//true
        System.out.println(person instanceof Person);//true
        System.out.println(person instanceof Singer);//true
        System.out.println(person instanceof Dancer);//false
//        System.out.println(person instanceof String);//编译不通过

        System.out.println("------------------------");

        Singer singer=new Singer();
        System.out.println(singer instanceof Object);//true
        System.out.println(singer instanceof Person);//true
        System.out.println(singer instanceof Singer);//true
//        System.out.println(singer instanceof Dancer);//编译不通过
//        System.out.println(person instanceof String);//编译不通过
    }

初始化顺序输出?

public class Person {
    //第二 ---->匿名代码块  可用于赋初始值
    {
        System.out.println("匿名代码块");
    }

    //第一 ---->静态代码块  只初始化一次
    static {
        System.out.println("静态代码块");
    }

    //第三 ---->无参构造器
    public Person() {
        System.out.println("无参构造器");
    }

    public static void main(String[] args) {
        new Person();
    }
}

内部类你知道多少?

成员内部类

局部内部类

静态内部类

匿名内部类

代码一运 啥都懂

public class Person {
    private String name;
    private int age=10;

    public void all(){
        System.out.println("外部类-方法");

        new Person5().get();
    }
    //局部内部类
    public class Person2{
        private String goods;
        public void eat(String name,String goods){
            String str = new Person3().str;
            System.out.println(name+" 吃了一个 "+str+goods);
            //内部类可以直接获取外部类的私有属性
            System.out.println(name+" 今年 "+age);
            System.out.println("局部内部类-方法");
            //匿名内部类
            Person4 person4 = new Person4() {
                public void doing() {
                    System.out.println("匿名内部类-方法");
                    System.out.println(name + " 摘了一个 " + str + goods);
                }
            };
            person4.doing();
        }
    }

    //静态内部类
    public static class Person5{
        public void get(){
            System.out.println("静态内部类-方法");
        }
    }


}

/*
一个java类文件中  只能有一个public class  但是可以有多个class
 */
//成员内部类
 class Person3{
    public String str="red ";
     public static void main(String[] args) {
         System.out.println("成员内部类-main方法");
         Person person = new Person();
         person.all();
         Person.Person2 person2 = person.new Person2();

         person2.eat("小猪","apple");

     }
 }

 //接口  -->函数式接口-->可用lambda 1.8特性
 interface Person4{
    public void doing();
 }

异常抛出-够简单吧

public class Person {
    private String name;
    private int age=10;

    public int all(int x,int y){
        try {
            if (x==0){
                throw new RuntimeException();//主动抛出异常
            }
        } catch (RuntimeException e) {
            x=10;
            e.printStackTrace();
        }finally {
            return y/x;
        }
    }

}
 class TestE{
     public static void main(String[] args) {
        Person person = new Person();
         System.out.println(person.all(20, 10));

     }
 }

自定义异常你怎么玩的?

public class MyException extends Exception {
    private int code;
    public MyException(int code) {
        this.code = code;
    }

    @Override
    public String toString() {
        return "MyException{" +
                "code=" + code +
                '}';
    }
}

//测试
    public static void main(String[] args) {
        System.out.println(getX(0));
    }
    public static  int getX(int x){
        try {
            if (x==0){
                throw new MyException(x);
            }
        } catch (MyException e) {
            x=10;
            e.printStackTrace();
        }finally {
            return x;
        }
    }