Java学习笔记（一）

Java开发环境

• 编译期：Java经过编译，生成.class字节码文件。
• 运行期：JVM加载.class文件并运行。
• JVM：Java虚拟机，加载并运行.class
• JRE: Java运行时环境，除了包含JVM以外还包含了运行Java程序所必须的环境。
• JDK: Java开发工具包。除了包含JRE以外，还包含了开发Java程序所必须的命令工具。

  基本数据类型

类型	字节空间
boolean	1字节（8位）
char	2字节（16位）
int	4字节（32位）
float	4字节（32位）
double	8字节（64位）
long	8字节（64位）
举例float:
-2^31 ~ 2^31 - 1
##### 舍入误差
Java中默认的浮点型位Double。如果不加f而使用float会报错误：
```java
float price2 = 2.5f;
```
2进制中无法精确表示1/10，就像10进制中无法精确表示1/3一样。

所以2进制表示10进制时会有舍入误差，对于一些需要精确运算的场合会导致代码的缺陷：

double price = 3.0;
double price3 = 2.9;
System.out.println(price - price3);
//0.10000000000000009

输入函数

//导入
import java.util.Scanner;

Scanner scan = new Scanner(System.in);
int age = scan.nextInt();
System.out.println(age);

---

数组

数组的定义

        //数组的定义
        int[] array1 = new int[4];
        array1[0] = 10;
        array1[1] = 20;
        array1[2] = 30;
        int[] array2 = {1,4,7};
        int[] array3 = new int[] {2,3,8,9};
        System.out.println(array3.length);
        for (int i = 0; i < array1.length; i++) {
            System.out.println("_____" + array1[i]);
        }
        System.out.println(array3);
        int[] array4 = new int[10];
        for (int i = 0; i < array4.length; i++) {
            array4[i] = (int) (Math.random() * 100);
            System.out.println("_____" + array4[i]);
        }
        int[] arr1 = {10,123,34,255,167};
        int[] arr2 = new int[5];
        //复制数组元素：
        //原数组 -- 起始下标--目的数组--起始下标---复制原数组的元素长度
        System.arraycopy(arr1, 1, arr2, 0, 4);
        //复制数组元素：
        //需要导入import java.util.Arrays;
        //原数组---目标数组初始化的长度
        int[] arr3 = Arrays.copyOf(arr1, 10);

数组排序

        //对数组进行排序
        //对数组进行升序排序
        Arrays.sort(arr3);
        //对arr1进行冒泡排序
        //冒泡排序：Bubble sort
        for (int i = 0; i < arr1.length - 1;i++) {//5个数需要比较四轮
            for (int j = 0; j< arr1.length - 1 - i; j++) {
                if(arr1[i] > arr1[i + 1]) {
                    int temp = arr1[i];
                    arr1[i] = arr1[i + 1];
                    arr1[i + 1] = temp;
                }
            }
        }
        for (int i = 0; i < arr1.length; i++) {
            System.out.println("冒泡排序：" + arr1[i]);
        }
        //判断是否为质数
        int  tempInt = 37;
        boolean isPrimeNumber = true;
        //简单判断就是 i <= tempInt / 2;
        //此处用的是平方根
        for(int i = 0;i <= Math.sqrt(tempInt); i++) {
            if(tempInt % i == 0) {
                isPrimeNumber = false;
                break;
            }
        }
        if(isPrimeNumber) {  
            System.out.println("是质数");
        }else {
            System.out.println("不是质数");
        }

---

Java的继承

public class OverloadLearn {

    public static void main(String[] args) {
        Person people = new Person();
        people.logUserInfo(); //父类的调用
        Student aStudent = new Student();
        aStudent.logUserInfo();//子类的调用
        aStudent.logFinal();

        //父类的指针指向子类的对象（多态）向上造型
        Person aPeople = new Student();
        aPeople.logUserInfo();//子类的调用    
    }
}
class Person {
    int age;
    String name;
    void logUserInfo() {
        System.out.println("父类的调用");
    }
}
class Student extends Person {
    String school;
    //被static final修饰的为常量，声明即需要初始化，不能被改变
    static final String address = "中华人民共和国";
     void logUserInfo() {
//         super.logUserInfo();
        System.out.println("子类的调用");
    }
     void logFinal() {
         System.out.println(address);
     }
}

抽象类的继承

//有抽象方法，必须要声明为抽象类。并且抽象类不能够被实例化
//抽象类就是被用来继承的。
abstract class Shape {
    double c;
    abstract double area();//抽象方法
}
//必须实现父类的抽象方法
class Square extends Shape {
    double area() {
        System.out.println("这是子类实现的一个抽象方法");
        return 56.6;
    }
}

接口的定义和实现

定义接口，继承抽象类：

//定义接口
interface MyInterfaceOne {
    public static final double PI = 3.1415;
    int number = 25;//接口中默认为 public static final
    public abstract void showLog();//抽象方法
    void showMyLog();//默认就是 public abstract
    //error:常量必须要初始化
//    int a ;
}
interface MyInterfaceSecond {
    int age = 24;
    void showMySecondLog();
}
abstract class MyAbstractClass {
    abstract void showMyAbstractMethod();
}
//定义的类需要实现所声明的接口的方法
//接口和类是并列的关系
//接口也是可以继承的,类实现MyInterfaceThree的方法时，也需要实现MyInterfaceSecond接口的方法
//interface MyInterfaceThree extends MyInterfaceSecond {
//    
//}
class InterfaceClass extends MyAbstractClass implements MyInterfaceOne,MyInterfaceSecond{
    //继承抽象类的方法（必须实现）
    void showMyAbstractMethod() {
        System.out.println("_____继承抽象类的方法");
    }
    //注意：必须要加public（必须要实现）
    public void showLog() {
        System.out.println("这是showLog方法");
    }
    public void showMyLog() {
        System.out.println("这是showMyLog方法");
    }
    public void showMySecondLog() {
        System.out.println("这是showMySecondLog方法");
    }
}

实现：

InterfaceClass myClass = new InterfaceClass();
myClass.showMyAbstractMethod();
myClass.showLog();
myClass.showMyLog();
myClass.showMySecondLog();

内部类的定义

//内部类和外部类
class Mather {//外部类
    private String Name;
    Baby createBaby() {
        return new Baby();
    }
    class Baby {//内部类
        public void showMatherName() {
            System.out.println(Name);
            System.out.println(Mather.this.Name);
//            System.out.println(this.Name);error 
        }
    }
}

    public static void main(String[] args) {
        Mather myMather = new Mather();
//        Baby ba = new Baby();error : 内部类不能在外部实现
    }

匿名内部类

    public static void main(String[] args) {
        int number = 44;
        //error: 接口不能实例化
//        MyInterface interface = new MyInterface();Error
        //匿名类的定义和实现
        MyInterface myInterf = new MyInterface(){
            public void show() {
                System.out.println("调用了show方法");
            }
            //error:在MyInterface中未定义，是不允许新添加方法的。
//            public void myShow() {
//                System.out.println("调用了myShow方法");
//            }
            public void showNumber() {
                System.out.println(number);
            }
        };
        myInterf.show();
        myInterf.showNumber();
//        myInterf.myShow();error 
}
interface MyInterface {    
    public void show();
    public void showNumber();
}
}

---

字符串的操作

public static void main(String[] args) {
        String str = "Hello world";
        // 没有则返回-1
        int index = str.indexOf("w");
        System.out.println("_____" + index);
        // 重载方法从指定的位置查找
        int index1 = str.indexOf("w", 3);
        System.out.println("_____" + index1);
        String str2 = "0123456789";
        // 字符串的截取
        // 从index3 到index5（不包括5）
        String sub = str2.substring(3, 5);
        System.out.println("_____" + sub);// 34
        // 从index4开始到结束
        sub = str2.substring(4);
        System.out.println("_____" + sub);// 456789
        int indexOfNumber = str2.indexOf("3");
        System.out.println("indexOfNumber" + indexOfNumber);//
        String myUrl = "http://www.baidu.com";
        if (myUrl.startsWith("http")) {
            System.out.println("http开头");
            int start = myUrl.indexOf(".") + 1;
            int end = myUrl.indexOf(".", start);
            String subStr = myUrl.substring(start, end);
            System.out.println("=====" + subStr);// baidu
        } else {

        }
        // 获取inex为4的字符
        char myChar = str2.charAt(4);
        System.out.println("=====" + myChar);// 4

        String info = "上海自来水来自海上";
        boolean isTrue = true;
        // 判断是否为回文
        for (int i = 0; i < info.length(); i++) {
            if (info.charAt(i) != info.charAt(info.length() - 1 - i)) {
                isTrue = false;
                break;
            }
        }
        if (isTrue) {
            System.out.println("是回文");
        } else {
            System.out.println("不是回文");
        }

        // 改变大小写
        String str3 = "Hello World 我爱Java";
        String upperStr = str3.toUpperCase();
        System.out.println(upperStr);// HELLO WORLD 我爱JAVA
        String lowerStr = str3.toLowerCase();
        System.out.println(lowerStr);// hello world 我爱java

        // 数字转字符串
        int a = 1;
        double b = 2.2;
        String StrA = String.valueOf(a);
        String StrB = String.valueOf(b);
        System.out.println(StrA);//
        System.out.println(StrB);// 2.2

        String tempStr = "中华人民共和国";
        // 可变字符串
        //StringBuffer:考虑了线程安全 StringBuilder没有
//        StringBuffer strBuffer = new StringBuffer(null);
        StringBuilder strBuilder = new StringBuilder(tempStr);
        System.out.println(strBuilder);
        // 初始化一个空的可变字符串
        StringBuilder strNull = new StringBuilder();
        System.out.println(strNull);
        // 可变字符串转换为不可变字符串
        String unStringBuilderStr = strBuilder.toString();
        System.out.println(unStringBuilderStr);

        // 可变字符串的拼接（在末尾追加）
        strBuilder.append("万岁！！！");//中华人民共和国万岁！！！
        System.out.println(strBuilder);
        //可变字符串的替换
        strBuilder.replace(0, 7, "世界人民大团结");
        System.out.println(strBuilder);//世界人民大团结万岁！！！
        //删除指定范围的字符串(含头不含尾)
        strBuilder.delete(9, 11);
        System.out.println(strBuilder);//世界人民大团结万岁！
        // 可变字符串的插入（在前边插入）
        strBuilder.insert(0, "中华人民共和国万岁!");
        System.out.println(strBuilder);//中华人民共和国万岁!世界人民大团结万岁！
        //翻转字符串
        strBuilder.reverse();
        System.out.println(strBuilder);//！岁万结团大民人界世!岁万国和共民人华中
    }