java基础

1.java内部类：
1）静态内部类

/**
 * 静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问

 2、 如果外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；
 如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员

 3、 创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名= new 内部类();
 */

public class SOuter {
    public static void main(String[] args){
        SInner sInner=new SInner();
        sInner.test();

    }
    private int a=99;
    static int b=1;
    int[][] aa=new int[5][];
    public static class SInner{
        int b=2;
        public void test(){
            System.out.println("访问外部类中的b"+SOuter.b);
            System.out.println("访问内部类中的b"+b);
        }
    }

}

2）方法内部类

public class MOuter {
    public static void main(String[] args){
        MOuter mOuter=new MOuter();
        mOuter.show();

    }
    public void show()
    {
        final int a=25;
        int b=13;
        class MInner{
            int c=2;
            public void print(){
                System.out.println("访问外部类的方法中的常量a："+a);
                System.out.println("访问内部类中的变量c:"+c);
            }
        }
        MInner mInner=new MInner();
        mInner.print();
    }
}

2.子类父类的构造函数初始化，A类继承B类，创建子类对象过程中，先初始化B类的构造方法，再初始化A类的构造方法。类属性的初始化：先初始化父类的属性-》父类构造方法的属性初始化-》子类属性初始化-》子类构造方法初始化；
3.final关键字：final关键字可以修饰类，方法，属性，变量
final修饰类，则该类不允许被继承，
final修饰方法，则该方法不允许被覆盖（重写）
final修饰属性：则该类属性不会进行隐式的初始化（类的初始化属性必须有值）
或在构造方法中赋值；
final修饰变量，则该变量的值只能赋一次值，即变为常量；
4.子类与父类，内部类实现接口

public class MainTest {
    public static void main(String[] args){
        Phone phone=new Phone();//父类的引用指向本类
        Phone huaweiPhone=new HuaweiPhone();//父类的引用指向子类，继承是多态的基础
        Phone vivoPhone=new VivoPhone();
        //HuaweiPhone hwphone=new Phone();子类的引用不能指向父类
        phone.chat();
        huaweiPhone.chat();
        vivoPhone.chat();

        VivoPhone vivoPhone1=new VivoPhone();
        Phone phone1 =vivoPhone1;
        if(phone1 instanceof VivoPhone)
        {
            VivoPhone vivo=(VivoPhone)phone1;

        }
        else{
            System.out.println("Phone不能转化为vivophone");
        }
        if(phone1 instanceof HuaweiPhone)
        {
            HuaweiPhone Hw=(HuaweiPhone)phone1;

        }
        else{
            System.out.println("Phone不能转化为HuaweiPhone");
        }
        IPlayGame playGame=new HuaweiPhone();
        playGame.playGame();
        IPlayGame pg=new IPlayGame() {
            @Override
            public void playGame() {
                System.out.println("使用匿名内部类的方式实现接口");
            }
        };
        pg.playGame();
        new IPlayGame() {
            @Override
            public void playGame() {
                System.out.println("使用匿名内部类的方式实现接口2");
            }
        }.playGame();
    }
}

public class HuaweiPhone extends Phone implements IPlayGame {
    @Override
    public void chat() {
        System.out.println("华为手机可以连续通话2小时");
    }

    @Override
    public void playGame() {
        System.out.println("华为 手机玩游戏");
    }
}

public class VivoPhone extends Phone {
}

5.try…catch…finally
代码执行顺序：try中代码-> catch中代码->finally中代码->调用者包含try…catch…finally代码块的代码
6.自定义异常类：
手机坏了的异常类：

public class PhoneBadException extends Exception {

    public PhoneBadException()
    {
        
    }

    public PhoneBadException(String message)
    {
        //运行父类方法
        super(message);
    }
}

7.字符串String

public class HelloWorld {
    public static void main(String[] args) {
		String s1 = "imooc";
		String s2 = "imooc";
        
        //定义字符串s3，保存“I love”和s1拼接后的内容
		 String s3="I love"+s1;
		
        // 比较字符串s1和s2
		// imooc为常量字符串，多次出现时会被编译器优化，只创建一个对象
		System.out.println("s1和s2内存地址相同吗？" + (s1 == s2));
        
        //比较字符串s1和s3
		System.out.println("s1和s3内存地址相同吗？" +  (s1==s3)               );

		String s4 = "I love " + s1;
         //比较字符串s4和s3
		// s1是变量，s4在运行时才知道具体值，所以s3和s4是不同的对象
		System.out.println("s3和s4内存地址相同吗？" + (s4 == s3));
	}
}

String类型常用方法：

注：
1.字符串 str 中字符的索引从0开始，范围为 0 到 str.length()-1
2.使用 indexOf 进行字符或字符串查找时，如果匹配返回位置索引；如果没有匹配结果，返回 -1
3.使用 substring(beginIndex , endIndex) 进行字符串截取时，包括 beginIndex 位置的字符，不包括 endIndex 位置的字符。
4.“==” 和 equals() 的区别：
==: 判断两个字符串在内存中首地址是否相同，即判断是否是同一个字符串对象
equals(): 比较存储在两个字符串对象中的内容是否一致。
8.StringBuilder类
常用方法：