gxj 的 JAVA课记录

.java(源文件) -> .class -> 解释执行

输入

1
2
3
4
5
6
7
8
9
10
11
public class hello {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        // 分隔
        String[] line = sc.nextLine().split(" ");
        for(int i=0 ; i<line.length;i++) {
            // string -> int 
            System.out.println(Float.valueOf(line[i]));
        }
    }
}

跳出循环

1
2
3
4
5
abc: for(int i = 0;i<n;i++){
	if (i<0){
		break abc;
	}
}
1
2
3
4
5
6
7
// 构造方法主要为了定义初始化状态
// 没有返回值，如果没有构造方法，编译器提供缺省的构造方法，构造方法为空
// 构造方法的名字和类名相同
Point(int x, int y){
    this.x = x;
    this.y = y;
}
1
2
3
4
5
// 重载
// 方法名相同，功能类似，参数不同的方法
// 方法名相同，参数类型或者个数必须不同
// 返回类型和修饰符可以相同也可以不同
// 要把类当作一种类型来处理

==this==

可以简化构造函数

1
2
3
4
5
6
7
8
9
10
public class main{
    private int x;
	main(int x){
        this.x = x ;
    }
	public hahah (int a ){
		this(a);
	}
}
//  如果要调用构造函数，就需要使用new ....

静态方法中不能调用非静态的方法和引用非静态的成员变量

类 的修饰符只有Public 和 default

其他有四个…..

数组

1
2
3
4
5
6
7
8
9
10
11
12
int[] x ; 
// 声明数组时不能指定其长度，编译将出错
int[] x = {1，2，3};
// 只能在声明数组的同时进行静态初始化 不能写成 int[] x ; x= {1,2,3}
int[] x = new int[4]; // 使用这个
int[] x = new int[]{1,2,3,4,5,6} // 需要写成这样
int[] x = new int[4]{1,2,3,4} // 不能写成这样。
// 也可以写成
int[] x ; 
x = new int[4];

// Java中字符数组不能用 “字符串” 来初始化
1
2
3
4
// 遍历的 for each 语句
for (int i : arr ){
	System.out.println(i)
}
1
2
3
4
5
6
// 二维数组中
int[][] x; 
// 第一个一定要写，第二个不一定要写
// java中的二维数组就是 一维数组的集合
int[][] days = new int[3][12];
boolean holidays [][] = {{x,x},{xx}};

方法重写

1
2
3
4
5
/* 方法重写
     1. 子类继承父类
     2. 子类中的方法与父类中的方法具有相同的名称、参数列表和返回值类型
     3. 范围修饰符不能比父类中的方法的范围修饰符更严格
 */

继承中的构造函数

  1. 从某种意义上来说，构造函数也是被继承的

    1
    2
    3
    4
    5
    6
    7
    class v1 {
    	v1()
    }

    class v2 extends v1{
    	v2(){ super() }
    }

  2. 构造函数的继承同时也可以重载

子类对象的实例化

  1. 分配对象所需要的全部内存空间
  2. 按照继承关系，自顶向下显式初始化
  3. 按照继承关系，自顶向下调用构造函数

super 和 this 不能同时出现

多态

方法的重载和重写来体现多态

调用一个相同的函数，输出的结果是不一样的。

方法重载： 方法名相同，但是参数个数和参数类型不同—-静态多态性

方法重写：

instanceof

1
2
3
4
5
6
7
8
9
10
class Simple1 {
    public static void main(String args[]) {
        Simple1 s = new Simple1();
        System.out.println(s instanceof Simple1);// true
    }
}

s instanceof 本类
s instanceof 父类

强制转换

向上转型可以 – 子类到父类

向下转型不可以 – 父类到子类

文件

==流== 是一组有序的数据序列

操作类型 ：

  • 输入流
  • 输出流

处理方式

  • 字节流
  • 字符流 Unicode字符，有两个字节组成

根据位置

  • 节点流
  • 过滤流

A文件内容写到B文件 使用输入流还是输出流

输入输出是相对于程序来说的，而不是文件本身

输入流：读文件

输出流：写文件