Java的一些基础

一些容易遗忘的基础

简洁与（&&） 非简洁与（&）的区别：

&&只有在其左侧为true时才会运算其右侧的逻辑表达式；&不是；

移位运算符：

• << (左移，低位添0补齐)
• >> (右移，高位添符号位补齐)
• >>> (右移,高位添0补齐)

数组：

数组的声明：数据类型 [] 数组名 (在声明中不能指明数组的长度)

       // 声明数组：
        int [] score;
        String [] fruits;

数组的创建：数组名 = new 数据类型[数组长度]

        //创建数组
        score = new int[5];
        fruits = new String[10];

声明时创建：

        int []  score = new int[5];
        String [] fruits= new String[10];

---

内存中的一些区域

栈区：主要存放人们在程序中定义的变量，包括引用类型的变量；
堆区：所有 new 出来的东西都是在堆区‘’
代码区：
常量池区：

内存的分配与释放：

分配：分配是由程序完成的，基本数据类型通过声明变量直接就会在内存中开辟相应大小的存储空间；引用数据类型需要程序员通过new 动态的申请内存空间；
释放：在栈中分配的内存，当超出变量的作用域后会自动的释放该变量所分配的内存空间；在堆中分配的内存空间由JVM的垃圾回收机制进行回收。

---

访问控制修饰符的访问权限：

修饰符	同一类中	同一包中	子类中	不同包中
private	yes
默认	yes	yes
protected	yes	yes	yes
public	yes	yes	yes	yes

---

继承

• 父子类在同一包：子类可以继承父类非private修饰的成员变量和方法；
• 父子类不在同一包中：子类只能继承父类 public 和 protected 修饰的成员变量和方法；
• 子类无法继承父类的构造方法，一个子类只能有一个父类，但一个父类可以有多个子类 ；
  变量隐藏： 子类中的变量和父类的某个变量同名时（类型可以不相同），子类隐藏了继承的成员变量，即当子类对象调用这个成员变量时一定是在调用子类中声明定义的那个变量，而不是调用的父类中的那个。
  重写与重载：
• 重写：在继承中出现，指的是子类定义与父类完全相同的方法，修改方法的实现，达到改变继承来的行为的目的。
• 重载： 同一类中同名方法通过传递不同的参数执行得到不同的结果。

子类对象的构造过程：

1. 初始化父类的成员变量；
2. 调用父类的构造函数；
3. 初始化子类的成员变量；
4. 调用子类的构造方法；

final：

1. final 修饰的类不能被继承；
2. final 修饰的成员变量不能再被改变，它没有默认值，必须在声明时赋初始值；
3. final 修饰的方法不允许被重写；
4. final 修饰的方法参数不允许在方法体内重新赋值；

多态

含义：指的是对象调用相的方法执行的操作不同，或者说同一实现接口，使用不同的实例而执行不同的操作。

多态的实现过程：

1. 子类重写父类的方法；
2. 编译方法时，调用父类定义的方法；
3. 运行时根据实际创建的对象类型动态地决定使用哪个方法；

抽象类

1. 抽象类用 abstract 修饰，不能被实例化；
2. 抽象方法只允许声明，不允许实现，不允许使用final修饰抽象方法；
3. abstract类中可以有abstract方法，也可以没有，但是abstract方法一定在abstract类中；

接口（interface）

1. 接口可以被继承，它将继承父接口所有的属性和方法；
2. 接口体中不能存在构造方法，定义的方法只能是抽象方法；
3. 接口中的方法默认是public 和 abstract修饰的方法，变量默认是public static final修饰的变量；

接口和抽象类的异同：

• 相同：都不能直接实例化，只有通过多态性，由其子类实例化；
• 不同点：

1. 抽象类包括一般方法，抽象方法，变量，常量，而接口只能包括常量和抽象方法；
2. 抽象类可以有构造方法，接口不可以有；
3. 抽象类可以实现多个接口，而接口不能继承一个抽象类；
4. 继承抽象类时会引发单继承所带来的局限性，而通过实现接口的方式能够解决单继承带来的局限性；

异常

异常的分类

• printStackTrace()方法打印异常信息；
• getMessage()方法获取异常信息并在控制台打印；

throws与throw的区别：

• 1.throw用于java语言环境不能捕捉、由程序员自行产生并抛出的异常；throws用于声明在该方法内部抛出了异常；
• 2. throw位于方法内部；throws必须跟在方法参数列表之后，不能单独使用；
• 3. throw抛出一个异常对象，而且只能抛出一个；throws后面跟异常类，而且可以跟多个异常类；

//Throws使用实例
public class DivByZeroUseThrows {
    public static void main(String[] args) {
        try {
            DivByZero();
        } catch (InputMismatchException ex) {
            System.out.println("输入的除数必须是整数类型");
        } catch (ArithmeticException ex) {
            System.out.println("除数不能为0");
        } finally {
            System.out.println("欢迎使用本计算程序");
        }
    }

    /**
     * 处理除数为零的方法，方法中不处理异常
     *
     * @throws InputMismatchException
     * @throws ArithmeticException
     */
    private static void DivByZero() throws InputMismatchException, ArithmeticException {
        Scanner input = new Scanner(System.in);
        int x, y;
        System.out.println("请输入除数x:");
        x = input.nextInt();
        y = 10 / x;
        System.out.println("10/x的结果为：" + y);
        input.close();
    }
}

public class CheckAgeByThrow {
    public static void main(String[] args) {

        try {
            int age = chkAge("-23");
            System.out.println("年龄为" + age);
        } catch (Exception ex) {
            System.out.println("年龄数据有逻辑错误！");
            System.out.println(ex.getMessage());
        }
    }

    /**
     * 将年龄字符串信息转换为整形，并判断数据是否为合法的年龄数据
     * @param s
     * @return
     * @throws Exception
     */
    private static int chkAge(String s) throws Exception {
        int age = Integer.parseInt(s);
        if (age < 0) {
            throw new Exception("年龄不能为负数！");
        }
         //在使用throw语句抛出一个异常对象时，该语句后面的代码不会被执行，即下面这句代码不会被执行
        return age;
    }
    
}

自定义异常使用实例

//自定义的异常类
public class MyStrChkException extends Exception {
    private String content;

    public MyStrChkException(String content) {
        this.content = content;
    }

    public String getContent() {
        return content;             //获取描述方法
    }
}

//测试驱动类MyStrChkTest
public class MyStrChkTest {

    /**
     * 检查字符串中是否有非法字符
     *
     * @param str
     * @throws MyStrChkException
     */
    public static void chkstr(String str) throws MyStrChkException {
        char[] array = str.toCharArray();
        for (int i = 0; i < array.length - 1; i++) {
            //A a 0的ASSIC分别为 65 97 48
            if (!((array[i] >= 48 && array[i] <= 57) || (array[i] >= 65 && array[i] <= 90) || (array[i] >= 97 && array[i] <= 122))) {
                throw new MyStrChkException("字符串：" + str + "中有非法字符");

            }
        }
    }

    public static void main(String[] args) {
        String str1 = "asdS6a6s7";
        String str2 = "dasf%da";
        try {
            chkstr(str1);
            chkstr(str2);
        } catch (MyStrChkException e) {
            // e.printStackTrace();
            System.out.println(e.getContent());
        }
    }
}