Java瞎学速成记录

声明

本文基于C++、Python的语言基础进行学习

编译

通过javac进行编译我们的.java文件，编译后的文件是.class文件

运行

我们可以编译后的.class文件不能直接执行需要我们使用命令java <class file>

class文件时java对应的字节码文件，在类装载器、字节码校验器、解释器的作用下完成对应的解释，进而完成程序对应的功能

通关JVM虚拟机来进行后续的操作，使程序运行

一些特性

java有编译型与解释型的两种特征

java的实现方式都需要包含在一个类class中

其中主类main的为

pubilc static void main(String[] args){
	// XXX
}

简单的输出

System.out.println("XXX")

XXX可以替换为任意字符串

简单输入

相对输出而言输入读取需要我们加入一个包java.util.Scanner

import java.util.Scanner
public class Test{
	pubilc static void main(String[] args){
    	Scanner input = new Scanner(System.in);
	}
}

注释

与C 语言类似，java的注释包含三种：单行注释、多行注释、文档注释

单行注释：//

多行注释：/**/

文档注释：/** */

/**
 * @Description Hello
 */

标识符

标识符应该以字母，美元符号($)、或者下划线开始(_)

不能用关键字作为变量或者方法名

标识符使大小写敏感的，对于变量如：A和a是两个变量，同时在定义变量时不能够重复

可以使用中文作为变量名，但是不建议

数据类型

基本类型

和C 语言一样，拥有int(4字节)、short(2字节)、long(8字节)、float(4字节)、double(8字节)、char(2字节)

一位占八位二进制数 1 B(byte) = 8bit (位)

float类型要在数字后面加一个F

long类型要加一个L

同时不太一样的是java拥有char是占用两个字节的，对此java也引入了byte(1字节)数据进行替代

java中还有一个boolean类型与C 语言中的bool一样是属于布尔类型的，只有True和False两种状态，只占用一位

java中还有一个String类型，和C++中的相似

float存在有一个范围，存在有舍入误差，可能出现有接近但不等于的情况，计算后尽量不要使用浮点数进行比较，否则可能会出现错误的判断结果

可以使用一个库进行保存大数：BigDecimal

引用类型

引用类型包括类、接口、数组

类型转换

类型大小排序

byte -> short -> int -> long -> float -> double

知识点：byte/short/int/long在和int一起计算的时候都会转为int

类型转换方式

大转小强制转换。小转大自动转换

强制转换方式与C 语言方式相同：(类型)变量名

不能把对象类型转换为不相干的类型

同时转换的时候注意溢出问题

JDK7特性

数字之间可以加下划线分割，下划线不会被输出

int num = 100_0000_0000;

变量

Java变量定义方式与C 语言相同，不同的是将C中的const更改为了final来进行定义常量

运算符

在计算中，对于long、int、short、byte之间的运算，如果有long的参与，那么最后的结果便是long类型的，不存在long类型时，其他的类型相互运算后得到的结果是int类型的

幂运算

Math.pow(a,b) // a^b

使用Math类来计算a 的 b 次幂

短路运算

我们赋值时当存在有&&时当&&的前半部分为0时，后半部分的内容不会被执行

int a=5;
boolean c =(a<2)&&(a++>5);
System.out.println(a); // 5

特性

在输出的时候+可以作为连接符，将前后的内容进行连接后输出

System.out.println("XX"+"YY");
//XXYY

需要注意的是，当字符串(String)类型的在前，那么后面的+会被解析为连接符，如果字符串(String)类型的在后，那么前面的+会被解析为加法运算

包机制

Java提供了包机制，用于区别类名的命名空间

包的本质就是文件夹

包语句的语法格式：

package pk1[.pkg2[.pkg3 ...]];

一般使用公司域名倒置作为包名

为了使用某一个包的成员我们可以使用import进行导入

import pk1[.pkg2[.pkg3 ...]];

需要注意的是，package需要放在import上方

使用其他类的规则

• 使用同一个包中的类时，不需要导包
• 使用java.lang包中的类时，不需要导入
• 其他情况都需要导包
• 如果同时使用两个包中的同名类需要使用全类名

JavaDoc

javadoc命令是用来生成自己API文档的

参数信息

@author 作者
@version 版本号
@since 指明需要最早使用的jdk版本
@param 参数名
@return 返回值
@throws 异常抛出情况

可以在.java所在的路径下使用javadoc来进行创建相关的API文档

用户交互 Scanner

与其他的语言不太一样的是，Java是需要使用Scanner创建一个扫描器对象，来用于接收键盘数据

import java.util.Scanner;
Scanner scanner = new Scanner(System.in);

判断输入

Scanner.hasNext()

我们可以通过这个来进行判断用户是否输入

接收数据

我们需要使用next方式进行接收

String input = scanner.next();

当我们用完了IO类流后如果不关闭会一直占用资源，需要用完后就关掉

scanner.close();

next():
1、一定要读取到有效字符后才可以结束输入。
2、对输入有效字符之前遇到的空白，next()方法会自动将其去掉。

3、只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。

4、next()不能得到带有空格的字符串。
nextLine():
1、以Enter为结束符,也就是说nextLine()方法返回的是输入回车之前的所有字符

2、可以获得空白。

数组

首先必须声明数组变量，才能在程序中使用，数组声明通常有两种方式

int[] num;
int num[]; // 不推荐

Java通过使用new操作符来创建数组

num[] arrReVar = new dataType[arraySize];

数组对象本身是在堆中的

稀疏数组

当一个数组中元素大部分是0或者是同一值的数组时，可以使用稀疏数组来保存改数组

大致就是一个数组，我们将其抽象为一个另一个数组，将数组中的不为0的的数据的坐标，值进行记录，然后进行保存。

字符串

StringBuilder

StringBuilder对象：包含了两个方法，一个为append()另一个是reverse(),可以用于快速的拼接字符串和将字符串进行反转

StringBuilder sb = new StringBuilder();

其中可以包含为有参和无参两种方式进行实现，在括号内进行添加字符串即可创建有参构造

同时StringBuilder对象可以进行链式编程，直接后面加上一个.然后便可以继续添加后续的方法

集合

集合的的关键字是ArrayList，定义方式为ArraryList<E>，E 代表非基本数据类型如String，e

ArraryList<String> list = new ArrayList<>();

对应的集合的方法主要有如下几个：

增强for循环

Java5+的特性

int[] numbers = {1,2,3,4}; // 创建了一个数组
for(int x:numbers){
	// XXX
}

使用这个方式相当于是从numbers中获取每一个成员，与Python的for i in numbers:相同

方法

Java中函数被称之为方法，是用于解决一类问题步骤的有序组合

public class Main {
    public static void main(String[] args) {
        int sum = add(1,2);
        System.out.println(sum);
    }
    public static int add(int a,int b){
        return a+b;
    }
}

像上面的代码我们创建的函数需要加上一个static使其成为类成员，才能被我们的main方法进行调用

否则需要我们创建一个类对象，通过类对象进行获取对应的函数方法

重载

方法的重载的规则:

1. 方法名称必须相同。
2. 参数列表必须不同(个数不同、或类型不同、参数排列顺序不同等)。
3. 方法的返回类型可以相同也可以不相同。
4. 仅仅返回类型不同不足以成为方法的重载。

public class Main {
    public static void main(String[] args) {
        int sum1 = add(1,2);
        System.out.println(sum1);
        double sum2 = add(1.0,2.0);
        System.out.println(sum2);
    }
    public static int add(int a,int b){
        return a+b;
    }
    public static double add(double a,double b){
        return a+b;
    }
}

命令行传参

我们可以使用main中的args来实现main传参

public class Main {
    public static void main(String[] args){
        for(int i=0;i<args.length;i++){
            System.out.println("args[" + i+ "]" + args[i]);
        }
    }
}

可变参数

对于一个方法我们可能会有许多参数，我们不可能去一个个的重载，我们可以使用可变参数来进行传递多个参数

方法声明中，在指定参数类型后加一个省略号(…)，一个方法中只能指定一个可变参数，必须是方法的最后一个参数，任何普通的参数必须在它之前声明

public class Main {
    public static void main(String[] args){
        test(1,2,3,4,5);
    }
    public static void test(int ...i){
        for(int n=0; n <i.length;n++){
            System.out.println(i[n]);
        }
    }
}

类对象的创建

我们创建一个类，后需要通过实例化来进行使用，我们可以创建对应对象(使用new来进行默认的初始化以及对累中构造器的调用)

使用new关键字本质是在调用构造器

类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的，并且存在以下两个特点:

• 必须和类的名字相同
• 必须没有返回值类型，也不能写void

像 C++ 中的构造以及析构函数，一旦定义了有参构造，无参就必须显示定义

属性私有

我们将属性设置为私有，使用private方式，我们获取到对应的数据需要使用getSet，使用this的方式来进行初始化

public int getAge(){
	return age;
}
public int setAge(){
	this.age = age;
}

使用封装，可以避免程序直接访问，提高数据的安全性，以及提高系统的可维护性。

继承

关键字：extends，意思是扩展，子类是父类的扩展

需要注意的是Java中只有单继承，没有多继承

子类可以继承父类的各种方法，子类不能继承父类私有项和保护项

Java中，所有的类默认都直接或者间接继承Object类

子类使用父类中成员时，需要使用关键字super

super调用父类的构造方法，必须在构造方法的第一个

super必须只能出现在子类的方法或者构造方法中

super和this不能同时调用构造方法

方法重写

父类的引用可以指向子类，对于方法的调用，只和左边定义的数据类型相关

方法相当于子类继承父类后将父类中的方法进行了重写

与C++的虚函数与纯虚函数相似，此处略过

接口

接口是使用interface来进行定义

public interface 接口名 {}

接口不能实例化，接口和类之间是实现关系，通过implements关键字表示

public class 类名 implements 接口名 {}

接口的子类要么重写接口中的所有抽象方法，要么是抽象类

接口中成员变量的默认修饰符是public，接口没有构造方法，成员方法默认修饰符：public abstract