自己学习JAVA整理的基础知识

public static void main(String[] ?args){

}

public?? ?访问修饰符（设置类可以被谁调用）
static ?? ?关键字
void ?? ?返回类型
main ?? ?方法名
String[] ?? ?字符串数组
args ?? ?变量名

访问控制修饰符
????????default?? ?在同一包内都可以用，?? ?使用对象：类、接口、变量、方法。
????????private?? ?在同一类中可用，?? ??? ?使用对象：变量、方法。
????????public?? ?对所有类可用，?? ??? ?使用对象：类、接口、变量、方法。
????????protected?? ?对同一包内的类和子类可用，?? ?使用对象：变量、方法。

在java中，被继承的类我们称之为父类，也叫基类；继承的类叫子类，也称派生类或超类。
类的继承（extends），继承属性和方法，以及重写、super关键字

数组的定义：类型[ ] 名字 =new 类型[ ]{写内容的地方，类型相同} ? int[] ?arr=new int[]{1，2，3，4，5}
?? ? ? 简写 类型[ ] 名字 ={写内容的地方，类型相同} ? int[] ?arr={1，2，3，4，5}
?? ? ? ?动态数组：类型[ ] 名字 =new 类型[ 数组中的数量] ?int[] ?arr=new int[5]
?? ?动态数组，整数默认0，浮点数默认0.0，boolean默认false，引用类型(类、接口、数组、String)默认null
? ?二维数组: ?类型[][] 名字 =new int[][]{{},{}}; ?int[][] arr=new int[][]{{1,2,3},{11,22,33}};
?? ? ? 可以简写
? ? ? ?类型[][] 名字 =new int[写可以存几个一维数组][写一维数组中内容数] ?int[][] ?arr=new int[3][5]

java的内存分配
栈：?? ?方法运行时使用的内存，比如main方法运行，进入方法栈中执行。
堆：?? ?储存对象或者数组，new来创建的，都在堆内存。
方法区：?? ?储存可以运行的class文件。
本地方法栈：JVM在使用操作系统功能的时候使用，和开发无关。
寄存器：?? ?给CPU使用，和开发无关。

方法的用法
方法的重载(同类同名不同参数)：在定义一个方法的时候，如果在同一个类中，同名，并且参数不同，java虚拟机会认为是不同的方法。
?? ?this( 参数列表 ）
?? ?这个用在我们类的构造器中，用来指向另一个构造器,如果参数列表为空，那就是指向无参构造器，
?? ??? ??? ? ? ? ? ? ?如果有参数，就按照参数列表的形式来指向，无参构造器的重载。
如何修改main中的变量：在main中调用类中的方法后，只是修改了方法内部的值，在main中需要接收这个方法的返回值，才可以改变main中的变量。
构造方法：主要是对类的参数进行设置，每个类都会默认一个无参数的构造方法，但是如果自己定义了一个构造方法，那么就没有无参构造方法了，
?? ?一般情况下，我们如果要定义一个构造方法，需要在定义一个无参的构造方法。

String（字符串)
1.String a="abc" 是堆区中的串池中，把地址赋给变量，如果值相同可以服用，节省空间。
2.String a=new String("hello") ?用new构造是在堆区开辟一个空间，把地址赋给变量，不能复用。
3.字符串拼接：（1）都是字符串，java的机制会把这些字符串看成一体的，可以服用串池中的数据。
?? ? ? ? ?（2）如果有变量和字符串一起拼接，那么在编译的时候，会new一个StringBuilder() 把字符串放进去，在new 一个String 去转化成字符串,比较浪费内存。
4.StringBuilder：new的时候会在堆区开辟一个空间，默认初始长度为16
?? ? ? ? ? ? 如果输入的内容超过16，会触发扩容，16*2+2的长度，如果输入的长度大于扩容之后的空间，那么就以输入的长度为StringBuilder的容量。

自己练习的文件

public class Demo3Application {
    // 成员变量
    private int age=188;
    public  void getAge(){
        // 局部变量
        int age=111;
        System.out.println(age);
    }

    //重载整数相加
    public static void sum(int a,int b){
        System.out.println(a+b);
    }
    public static void sum(double a,int b){
        System.out.println(a+b);
    }
    public static int sum(int a,int b,int c){
        System.out.println(a+b+c);
        return a+b+c;
    }
    public static void sum(int a,int b,int c,int d){
        System.out.println(a+b+c+d);
    }
    //拷贝数组(按索引拷贝)
    public static int[] cope(int[] copeArr,int from,int to){
        int[] arr=new int[to-from];
        int index=0;
        for (int i = from; i < to; i++) {
            arr[index]=copeArr[i];
            index++;
        }

        return arr;
    }
    public static int change(int count){
        count=200;
        return count;
    }


    public static void main(String[] args) {
//        SpringApplication.run(Demo3Application.class, args);
        Son myClass=new Son();
        System.out.println(myClass.age);
        myClass.study();
        System.out.println("键盘录入使用Scanner one =new Scanner(System.in);");
/*       键盘录入
        Scanner one =new Scanner(System.in);
        Scanner two =new Scanner(System.in);
        System.out.println("请输入第一个数：");
        int x=one.nextInt();
        System.out.println("请输入第二个数：");
        int y=two.nextInt();
        System.out.println("输出："+(x+y));
 */
 /* 创建一个数组
        double[] arrNew=new double[]{1.1,3,2.2,5,6};
        int[] arr={1,2,3,4,5};
        System.out.println(arr);//[I@26ba2a48  “[”代表是数组,I代表是整型，@是固定符号，后面是储存地址
        System.out.println(Arrays.toString(arr));
        System.out.println(Arrays.toString(arrNew));
        int a=arr[0];
        System.out.println(a);
        int result=0;
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
            result+=arr[i];
        }
        System.out.println(result);
        int[] arr2=new int[10];
        System.out.println(Arrays.toString(arr2));
        char[] arr3=new char[10];
        System.out.println(Arrays.toString(arr3));
        //求数组最大值
        //1
        double max=arrNew[0];
        for (int i = 0; i < arrNew.length; i++) {

            if(max<arrNew[i]){
                max=arrNew[i];
            }
        }
        System.out.println(max);
        //2
        for (int i = 0; i < arrNew.length-1; i++) {
            for (int b = 0; b < arrNew.length-1-i; b++) {
                if(arrNew[b]>arrNew[b+1]){
                    double temp=arrNew[b];
                    arrNew[b]=arrNew[b+1];
                    arrNew[b+1]=temp;
                }
            }
        }
        System.out.println(Arrays.toString(arrNew));
 */
  /*    方法的重载(同类，同名，不同参(参数的类型不同也可以)，和返回值无关)
        sum(1,2);
        sum(1.1,2);
        sum(1,2,3);
        System.out.println(sum(1,2,3));
        sum(1,2,3,4);
   */
    /* 复制数组，二维数组
        int[] arr1=new int[]{1,2,3,4,5,6,7,8,9};
        int[] cope = cope(arr1, 2, 6);
        System.out.println(Arrays.toString(cope));
        int a=100;
        a=change(a);
        System.out.println(a);
        int[][] arr2=new int[][]{{1,2,3,4,5},{11,22,33,44,55}};
        System.out.println(Arrays.toString(arr2[1]));
     */
        System.out.println("随机数：Random ran= new Random();");
        Random ran= new Random();
        int a=ran.nextInt(100);
        System.out.println(a);
        Demo3Application myClass1=new Demo3Application();
        myClass1.getAge();
        Dome1 myAaa=new Dome1();
        myAaa.aaa();
    }

}
class Father{
     int age=20;
     void study(){
         System.out.println("学习java，努力努力");
     }
}
class Son extends Father {
    @Override
    void study(){
        System.out.println("子类中使用@Override覆盖父类的方法");
    }

}

?