JAVA学习笔记

Java 学习笔记

（PS：java是一种面向对象的编程语言，它比c++更纯粹，面向对象的特性体现的更明显）

环境

1、编译过程

• 创建一个.java后缀的文件，并编辑
• javac编译（Java compile=> javac），会产生.class文件
• java指令运行代码

2、IDE运行：

• Intellij idea - 推荐（第三方的平台可以自动帮你配置java编译运行时所需要的环境，更加方便）
• eclipse

3、配置环境：

Java环境

• jdk-Java development kit，用来编译你的java代码的工具
• jre-Java runtime environment，用来运行你的Java程序的环境（虚拟机）

因为intellij idea已经给你封装好了环境，所以你就可以直接运行，省去配置的过程。

语法

1、运行的框架：

Java oop object oriented programming 面向对象编程

• class里边写main函数，然后不能在class外边写，可以认为类是编译时的唯一接口，写在类外面的东西没办法发现它。（这样main函数就无法编译了）
• 一个类class里边，最多只有一个main函数。
• main函数的写法：省略（可以利用intellij的自动提示）

2、基本语法-几种数据类型：

对比C++

C++：int char string double float

Java基本数据类型：byte short int long char double boolean float

Java常用的类：Integer（类） Double（类）String（类）

3、基本语法-条件分支语句

// 条件分支
if (a == b) {
    System.out.println("a等于b");
} else {
    System.out.println("a不等于b");
}
if (a == b) {

} else if (a > b) {

} else { // a<b

}
int d;
//特别强调从控制台读入时，要引入import java.util.Scanner这个包。
Scanner scanner = new Scanner(System.in); //cannot resolve constructor Scanner() 无法解析出Scanner()这个构造函数，所以括号内要有参数
d = scanner.nextInt();
switch (d){
    case 1:
        System.out.println("该数为1");break;
    case 2:
        System.out.println("该数为2");break;
    default:
        System.out.println("该数不是1也不是2");break;
}
if (a == 1){
    if (b == 2) {

    }
}
System.out.println("刚才读入的是"+d);

4、基本语法-循环

// 循环
// 数组中常用到循环
int[] arr1;
int[] arr2 = new int[50];
for (int i = 0; i < 50; i++) {
    System.out.println(arr2[i]);
}
System.out.println("另一种遍历方式");
for (int tem: arr2){//就是创建一个相同类型的临时变量，将遍历到的每一个值都赋给这个临时变量
    System.out.println(tem);
}
// while() {}
System.out.println("while的遍历方式");
int idx = 0;
while (idx < 50) {
    System.out.println(arr2[idx]);
    idx++;
}

5、基本语法-函数

第一种方法

public class one {
    public static void main(String[] args) {
        // 第一种调用方式=> 声明（初始化）一个该类的对象，然后调用这个对象的方法（P:可以这样理解因为java是面向对象的编程语言，类类似于一个蓝图，没有实物，只有当用这个蓝图创建出一个对象时，才可以通过对象来使用函数））
        one object_one = new one();
        object_one.methedone();
        object_one.methedtwo(2);
        int num1 = object_one.methedthree();
        int num2 = object_one.methodfour(6, 7);
        System.out.println(num1+" "+num2);
    }
    // 无参数、无返回值的函数
    public void methedone () {
        System.out.println("这是一个无参数无返回值的函数");
    }
    // 有参数、无返回值的函数
    public void methedtwo (int num) {
        System.out.println("这是一个有参数无返回值的函数，且传进来的参数为"+num);
    }
    // 无参数、有返回值的函数
    public int methedthree() {
        int temnum = 5;
        System.out.println("这是一个无参数有返回值的函数");
        return temnum;
    }
    // 有参数、有返回值的函数
    public int methodfour(int a, int b) {
        System.out.println("这是一个有参数有返回值的函数，且传进来的参数为 "+a+" "+b);
        return a+b;
    }
}

第二种：将被调用的方法变为静态方法，然后直接调用即可。（因为main函数是个静态的函数，无法调用非静态的属性，方法，只有将方法也声明为静态的才可以调用）

public class one {
    public static void main(String[] args) {
        methedone();
        methedtwo(5);
    }
    // 无参数、无返回值的函数
    public static void methedone () {
        System.out.println("这是一个无参数无返回值的函数");
    }
    // 有参数、无返回值的函数
    public static void methedtwo (int num) {
        System.out.println("这是一个有参数无返回值的函数，且传进来的参数为"+num);
    }
    // 无参数、有返回值的函数
    public int methedthree() {
        int temnum = 5;
        System.out.println("这是一个无参数有返回值的函数");
        return temnum;
    }
    // 有参数、有返回值的函数
    public int methodfour(int a, int b) {
        System.out.println("这是一个有参数有返回值的函数，且传进来的参数为 "+a+" "+b);
        return a+b;
    }
}

6、类与对象

• 如果没有写任何的构造函数，那我们就可以默认直接用无参数的构造函数。
• 如果写了有参数的构造函数，那如果我们要到了无参数的构造函数的时候，我们就要把无参数的构造函数补充上去 =》两层含义
• 注：一个.java文件里只能写一个类，在同一个文件夹下面的两个类是不用引入就可以使用的，但是使用时必须得加类名，否则编译器默认是在当前文件下去寻找，会报错。

one.java

public class one {
    public static void main(String[] args) {
        one.methedone();
        methedtwo(5);
        // 类与对象1、引入-涉及到作用域的问题 2、声明（初始化）
        // 因为作用域的问题，我在此处就可以直接引入two这个类
        two object_two = new two();// 构造其他类的对象，不一定只用默认的无参数构造函数
        object_two.methodfive();
        two.methodsix(9);
        two with_param_object_two = new two(100);
        System.out.println(with_param_object_two.mynum);

    }
}

two.java

public class two {
    int mynum;
    public two (){}
    public two(int num) {
        this.mynum = num;
    }

    // 无参数、无返回值
    public void methodfive() {
        System.out.println("这是来自class two的函数五");
    }
    // 静态的 有参数、无返回值
    public static void methodsix(int num) {
        System.out.println("这是一个静态的，有参数无返回值，返回值为 "+num);
    }
}

7、继承

public class three extends two {}

// 继承 => 把父类的所有属性和所有方法都拿过来用
three object_three = new three();
object_three.methodsix(4);
object_three.methodfive();
System.out.println(object_three.mynum);

8、关于作用域的问题

// 关于作用域的问题
two object_two = new two();
System.out.println(object_two.getSecretnum());
object_two.setSecretnum(777);
System.out.println(object_two.getSecretnum());

9、调用其他的类-现成的类java.util，并使用该类的功能：

a) import这个类：

import java.util.Scanner;

b) 声明一个这个类的对象：=>初始化一个对象 // 相当于利用构造函数构造一个对象 {默认构造函数，有参数构造函数，无参数构造函数}

Scanner scanner = new Scanner(System.in); //cannot resolve constructor Scanner() 无法解析出Scanner()这个构造函数

c) 使用这个类在此处声明的（初始化的）对象的方法：

scanner.nextInt(); //这个方法是返回一个数据类型为int的值，所以要把这个返回值赋给一个数据类型为int的变量
int d = scanner.nextInt();

10、调用其他的类-自己写的类 public class CMclass，import CMclass

也就是第6条