Java基础2

IDEA快捷键：

数组：
动态初始化数组：int[] array = new int[20];
静态初始化：int[] array = new int[] {1,2,3};
int[] array = {1,2,3}(省略形式);

Java的内存分为5个部分：
1.栈：存放的都是方法中的局部变量。方法的运行一定要在栈中。局部变量：方法的参数，或者是方法{}内部的变量。
作用域：一旦超出作用域，立刻从栈内存中消失。
2.堆：凡是new出来的东西，都在堆中。
堆内存里面的数据，都有默认值。规则：
如果是整数 默认为0
如果是浮点数 默认为0.0
如果是字符 默认是’\u0000’
如果是布尔值 默认为false
如果是引用类型 默认为null
3.方法区：存储.class相关信息，包含方法的信息。
4.本地方法栈：与操作系统相关
5.寄存器：与CPU相关
一个对象的内存图：

局部变量和成员变量的区别：
1.定义的位置不一样
局部变量：在方法的内部
成员变量：在方法的外部，直接写在类当中
2.作用范围不一样
局部变量：只有方法当中才可以使用，出了方法就不能再用
成员变量：整个类都可以用
3.默认值不一样
局部变量：没有默认值，如果要想使用，必须手动进行赋值
成员变量：如果没有赋值，会有默认值，规则和数组一样

ArrayList集合：
常用方法：
public boolean add(E e):向集合当中添加元素，参数的类型和泛型一致
public E get(int index):从集合当中获取元素，参数是索引编号，E返回值就是对应位置的元素
public E remove(int index):从集合当中删除元素，参数是索引编号，返回值就是被删除的元素
public int size();获取集合的尺寸长度，返回值就是集合中包含的元素个数

package listt;

/**
 * ArrayList集合：
 * 常用方法：
 * public boolean add(E e):向集合当中添加元素，参数的类型和泛型一致
 * public E get(int index):从集合当中获取元素，参数是索引编号，E返回值就是对应位置的元素
 * public E remove(int index):从集合当中删除元素，参数是索引编号，返回值就是被删除的元素
 * public int size();获取集合的尺寸长度，返回值就是集合中包含的元素个数
 */

import java.util.ArrayList;

public class ArrayListDemo {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);//添加元素
        list.add(2);
        list.add(3);
        System.out.println(list);
        System.out.println(list.get(1));//获取指定位置的元素
        System.out.println(list.remove(1));//删除指定位置的元素
        System.out.println(list.size());//获取元素个数
    }
}

字符串：
三种构造方法（3+1）：
public String():创建一个空白字符串，不含有任何内容
public String(char[] array):根据字符数组的内容，来创建对应的字符串
public String(byte[] array):根据字节数组的内容，来创建对应的字符串
一种直接创建：

package listt;

public class stringDemo {
    public static void main(String[] args) {
        //使用空参构造
        String str1 = new String();
        System.out.println(str1);
        //使用字符数组创建字符串
        char[] array = {'a','b','c','d'};
        String str2 = new String(array);
        System.out.println(str2);
        //根据字节数组创建字符串
        byte[] byteArray = {97,98,99};
        String str3 = new String(byteArray);
        System.out.println(str3);
        //直接创建
        String str = "abcdef";
        System.out.println(str);


    }
}

字符串常量池：
程序中直接写上的双引号字符串，就在字符串常量池中
字符串的常用方法：
1.比较方法：
public boolean equals(Object obj):参数是任何对象
备注：任何对象都能用Object接收
2.字符串中获取相关的常用方法
public int length():获取字符串中含有的字符个数，拿到字符串的长度
public String concat(String str):将当前字符串和参数字符串拼接成为返回值新的字符串
public char charAt(int index):获取指定索引位置的单个字符。
public int indexOf(String str):查找参数字符串在本在字符串当中首次出现的索引位置，如果没有返回-1

//2.字符串中获取相关的常用方法

        //获取字符串的长度
        int length = "abcdefgh".length();
        System.out.println(length);

        //拼接字符串
        String str4 = "hello";
        String str5 = "world";
        String str6 = str4.concat(str5);
        System.out.println(str4);
        System.out.println(str5);
        System.out.println(str6);

        //获取单个字符
        String str7 = "Hello";
        char ch = str7.charAt(1);
        System.out.println(ch);

        //查找参数字符串在本来字符串当中出现的第一次索引位置
        String original = "HelloWorld";
        int index = original.indexOf("llo");
        System.out.println(index);

字符串截取方法：
public String substring(int index):截取从参数位置一直到字符串末尾，返回新字符串
public String substring(int begin,int end):截取从begin位置开始，一直到end结束，中间的字符串。[begin,end)，是一个左闭右开的区间。

package listt;

/**
 * 字符串截取方法：
 * public String substring(int index):截取从参数位置一直到字符串末尾，返回新字符串
 * public String substring(int begin,int end):截取从begin位置开始，一直到end结束，中间的字符串。[begin,end)，是一个左闭右开的区间。
 */

public class stringDemo3 {
    public static void main(String[] args) {
        String str1 = "HelloWorld";
        String str2 = str1.substring(5);
        System.out.println(str2);
        String str3 = str1.substring(1,4);
        System.out.println(str3);
    }
}

字符串当中转换相关常用方法：
public char[] toCharArray():将当前字符串拆分成为字符数组作为返回值。
public byte[] getBytes():获得当前字符串底层的字节数组
public String replace(CharSequence oldString,CharSequence newString):将所有出现的老字符串替换成为新的字符串，返回替换之后的结果新字符串

package listt;

/**
 * 字符串当中转换相关常用方法：
 * public char[] toCharArray():将当前字符串拆分成为字符数组作为返回值。
 * public byte[] getBytes():获得当前字符串底层的字节数组
 * public String replace(CharSequence oldString,CharSequence newString):
 * 将所有出现的老字符串替换成为新的字符串，返回替换之后的结果新字符串
 */

public class stringDemo4 {
    public static void main(String[] args) {
        char[] chars = "Hello".toCharArray();
        System.out.println(chars);
        System.out.println(chars.length);

        System.out.println("========================");
        byte[] bytes = "abc".getBytes();
        System.out.println(bytes.length);
        for (int i = 0; i < bytes.length; i++) {
            System.out.println(bytes[i]);
        }

        System.out.println("================================");
        String str1 = "How do you do?";
        String str2 = str1.replace("o","*");
        System.out.println(str2);
        System.out.println(str1);
    }
}

字符串的分割：
public String[] split(String regex):按照参数规则，将字符串切分成为若干部分。
注意事项：split方法的参数其实是一个“正则表达式”，如果按照英语句点“.”进行切分，必须写“\.”。

package listt;

/**
 * 字符串的分割：
 * public String[] split(String regex):按照参数规则，将字符串切分成为若干部分。
 * 注意事项：split方法的参数其实是一个“正则表达式”，如果按照英语句点“.”进行切分，必须写“\\.”。
 */

public class stringDemo5 {
    public static void main(String[] args) {
        String str1 = "aaa,bbb,ccc";
        String[] strs = str1.split(",");
        for (int i = 0; i < strs.length; i++) {
            System.out.println(strs[i]);
        }
        System.out.println(strs);

        String str2 = "XXX.YYY.ZZZ";
        String[] strs1 = str2.split("\\.");
        for (int i = 0; i < strs1.length; i++) {
            System.out.println(strs1[i]);
        }

    }
}

static:
一旦使用static修饰成员方法，那么就成为了静态方法，静态方法不属于对象，而是属于类的。
如果没有static关键字，那么必须先创建对象，然后通过对象才能使用它。
如果有了static关键字，那么不需要创建对象，直接就能通过类名称来使用它。
无论是成员变量还是成员方法，如果有了static，都推荐使用类名称进行调用

注意事项：
1.静态方法不能访问非静态变量
原因：因为在内存中是先有静态内容，后有非静态内容
2.静态方法中不能使用this

package listt;

public class staticDemo {
    int num;
    static int numStatic;

    public void method(){
        System.out.println("这是一个成员方法");
        //成员方法访问成员变量
        System.out.println(num);
        //成员方法访问静态成员变量
        System.out.println(numStatic);
    }

    public static void metnodStatic(){
        System.out.println("这是一个静态方法");
        //静态方法可以访问静态变量
        System.out.println(numStatic);
        //静态方法不能访问非静态变量
        //System.out.println(num);
        //静态方法中不能使用this关键字
        //System.out.println(this);
    }
}

静态代码块：
静态代码块类：

package listt;

public class staticDemo2 {
    static {
        System.out.println("静态代码块执行");
    }

    staticDemo2(){
        System.out.println("构造方法执行");
    }
}

静态代码块类调用：

package listt;


/**
 * 静态代码块的格式
 * public class 类名称{
 *     static {
 *         //静态代码块内容
 *     }
 * }
 *
 * 特点：当第一次用到本类时，静态代码块执行唯一一次
 * 静态内容总是优先于非静态内容，所以静态代码块比构造方法先执行
 *
 * 静态代码块的典型用途：
 * 用来一次性地对静态成员变量进行赋值
 */

public class testMain {
    public static void main(String[] args) {
        staticDemo2 one = new staticDemo2();
        staticDemo2 two = new staticDemo2();
    }
}

Arrays工具类：
public static String toString(数组)：将参数数组变成字符串
public static void sort():按照默认升序（从小到大）对数组进行排序

备注：
如果是自定义的类型，那么这个自定义的类需要有Comparable或者comparator接口的支持

package listt;

import java.util.Arrays;

public class ArraysDemo {
    public static void main(String[] args) {
        int[] intArray = {10,20,30};
        String intStr = Arrays.toString(intArray);
        System.out.println(intStr);

        int[] array1 = {2,1,3,10,6};
        Arrays.sort(array1);
        System.out.println(Arrays.toString(array1));

        String[] array2 = {"aaa","bbb","ccc"};
        Arrays.sort(array2);
        System.out.println(Arrays.toString(array2));
    }
}

继承：
继承主要解决的问题就是：共性抽取（可以解决重复代码的问题）
继承关系当中的特点：
1.子类可以拥有父类的内容
2.子类可以拥有自己专有的内容

变量重名问题：
使用就近原则

package extendDemo1;

public class Employee {
    int num = 10;
    public void method() {
        System.out.println(num);
    }
    /*public void method(){

        System.out.println("方法执行！");

    }*/
}

package extendDemo1;

//定义一个子类讲师
public class Teacher extends Employee {
    int num = 20;
    public void methodTeacher(){
        int num = 30;
        System.out.println(num);
        System.out.println(this.num);
        System.out.println(super.num);
    }

}

package extendDemo1;

public class extendDemo01 {
    public static void main(String[] args) {
        Teacher teacher = new Teacher();
        teacher.method();
        System.out.println("=================================");
        teacher.methodTeacher();
    }
}

成员方法覆盖重写：

super的三种用法:

this的三种用法：

super与this内存图解：

Java继承特点：
1.单继承
2.可以有多级继承

抽象类：
如果父类当中的方法不确定如何进行{}方法体实现，那么这就应该是一个抽象方法。

package abstractDemo;

/**
 * 抽象方法：就是加上abstract关键字，然后去掉大括号，直接分号结束
 * 抽象类：抽象方法所在的类，必须是抽象类。在class之前加上abstract即可
 *
 * 如何使用抽象类和抽象类方法
 * 1.不能直接创建new抽象类对象
 * 2.必须用一个子类来继承抽象父类
 * 3.子类必须重写抽象父类当中所有的抽象方法
 * 覆盖重写：子类去掉抽象方法的abstract关键字，然后补上方法体
 */

public abstract class abstractDemo01 {
    
    public abstract  void eat();

    public void method(){

    }
}

package abstractDemo;

public class Cat extends abstractDemo01 {
    @Override
    public  void eat(){
        System.out.println("猫吃鱼");
    }
}

package abstractDemo;

public class mainDemo {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.eat();
    }
}

抽象类注意事项：

接口：接口是一种公共的规范标准
接口中的抽象方法：

package Myinterface;

/**
 * 接口中可以含有的内容：常量、抽象方法、默认方法、静态方法
 * 在任何版本中，接口都能定义抽象方法
 * 格式：
 * public abstract 返回值类型 方法名称（参数表）；
 *
 * 注意事项：
 * 1.在接口当中的抽象方法，修饰符必须是两个固定的关键字：public abstract
 * 2.这两个关键字修饰符，可以选择性地省略
 * 3.方法的三要素随意定
 */


/**
 * 接口使用步骤：
 * 1.接口不能直接使用，必须要有一个“实现类”来实现接口。
 * 格式：
 * public class 实现类名称 implements 接口名称{
 *     //
 * }
 * 2.接口的实现类必须覆盖重写接口中所有的抽象方法，去掉abstract关键字，加上方法体
 * 3.创建实现类的对象，进行使用
 */

public interface MyInterfaceAbstract {
    public abstract  void method();
}

package Myinterface;

public class MyInterfaceImpl implements MyInterfaceAbstract {

    @Override
    public void method() {
        System.out.println("这是一个方法");
    }
}

package Myinterface;

public class InterfaceDemoMain {
    public static void main(String[] args) {
        MyInterfaceImpl impl = new MyInterfaceImpl();
        impl.method();
    }
}

接口中的默认方法：

package Myinterface;

/**
 * 从Java8开始，接口允许有默认方法
 * 格式：
 * public default 返回值类型 方法名称（参数列表）{
 *     方法体
 * }
 * 备注：接口中的默认方法 ，可以解决接口升级问题
 * 
 * 1.接口的默认方法，可以通过接口实现类对象，直接调用
 * 2.接口的默认方法，也可以被接口的实现类进行覆盖重写
 */

public interface MyInterfaceDefault {
    //抽象方法
    public abstract void methodAbs();

    //新添加的默认方法
    public default void methodDefault()
    {
        System.out.println("This is a default method");
    }
}

package Myinterface;

public class InterfaceDemoMain {
    public static void main(String[] args) {
        MyInterfaceImpl impl = new MyInterfaceImpl();
        impl.method();

        System.out.println("===================================");
        MyInterfaceDefaultA impl2 = new MyInterfaceDefaultA();
        impl2.methodDefault();
    }
}

接口中的静态方法：

package Myinterface;

/**
 * 从Java8开始，接口当中就允许定义静态方法
 * 格式：
 * public static 返回值类型 方法名称（参数列表）{
 *     方法体
 * }
 * 提示：就是将abstract或者default换成static即可，带上方法体
 * 
 * 注意：不能通过接口实现类的对象来调用接口当中的静态方法
 */

public interface MyInterfaceStatic {
    public static void methodStatic(){
        System.out.println("This is a static method!");
    }
    
}

接口中的私有方法：

package Myinterface;

/**
 * 问题描述：
 * 我们需要抽取一个共有方法，用来解决两个默认方法之间重复代码的问题
 * 但是这个共有方法不应该让实现类使用，应该是私有化的。
 * 
 * 解决方案：从Java9开始，接口中允许定义私有方法
 * 1.普通私有方法，解决多个默认方法之间重复代码问题
 * 格式：private 返回值类型 方法名称（参数列表）{
 *     
 * }
 * 
 * 2.静态私有方法，解决多个静态方法之间重复代码问题
 * 格式：private static 返回值类型 方法名称（参数列表）{
 *     
 *  }
 */

public interface MyInterfacePrivate {
    public default  void methodDefault(){
        System.out.println("default method");
        methodCommon();
    }
    public default void methodDefault1(){
        System.out.println("default method one");
        methodCommon();
    }
    private void methodCommon(){
        System.out.println("common method");
    }
}

接口中的常量：

/**
     * 接口当中也可以定义成员变量，但是必须使用public static final
     * 三个关键字修饰
     * 从效果上看，这就是接口的常量
     * 格式：
     * public static final 数据类型 常量名称 = 数据值；
     */
    //这是一个常量，一旦赋值，不可以修改
    public static final int num = 10;

接口小结：

使用接口时，需要注意：
1.接口没有静态代码块和构造方法
2.一个类的直接父类是唯一的，但是一个类可以同时实现多个接口
3.如果实现类所实现的多个接口中，存在重复的抽象方法，那么只需要覆盖重写一次即可。
4.如果实现类没有覆盖重写所有接口中的所有抽象方法，那么实现类就必须是一个抽象类。
5.如果实现类所实现的多个接口中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写
6.一个类如果直接父类当中的方法和接口当中的默认方法产生了冲突，优先用父类当中的方法。

多态：extends或者implement,是多态性的前提；


final关键字：
修饰一个类：当前这个类不能有任何子类，不能被继承
修饰一个成员方法：当前这个方法不能被覆盖重写
修饰局部变量：变量的值不能再修改，引用类型除外

四种权限修饰符：

内部类：
1.成员内部类

2.局部内部类（包含匿名内部类）

匿名内部类：