标签：Java 入门 基础 System class println new Main public

一、 注释

方式	标识符
单行注释	//
多行注释	/* */
文档注释	/** */

二、 基础

1、 进制

进制	前缀
二进制	0b
八进制	0
十进制	无
十六进制	0x

2、 数据类型

type varName [=value][{,varName[=value]}];
byte num1=127;
short num2=32767;
int num3=2147483647;
long num4=9223372036854775807L;
float num5=2147483647f;
double num6=9223372036854775807;
boolean flag=true;
char a="A";

int num7=127;
byte num8=(byte)num7; //强制转换 (类型)变量名 高到低
double num9=num7; //自动转换 低到高

注：

1. 最好避免完全使用浮点数进行比较！！！
2. 类型转换时，小数的优先级一定大于整数
3. 不能对布尔值进行转换

3、变量、常量、作用域

① 变量

int i=10; //局部变量；必须声明和初始化值
Demo08 demo08=new Demo08(); //变量类型 变量名字=new 变量类型()
static double salary = 2500; //类变量
快捷键：typeName.new + Enter

② 常量

final double PI=3.14； //final 常量名=值

注：

1. 初始化后不能改变值
2. 常量名一般使用大写字符
3. 修饰符不存在先后限制

③ 命名规范

1. 类成员变量：驼峰原则 (除了第一个单词外，后面的单词首字母大写)
2. 局部变量：驼峰原则
3. 常量：字母大写，下划线间隔
4. 类名：单词首字母大写
5. 方法名：驼峰原则

4、 运算符

基本与C语言相同

1. +可以做字符串连接符
2. instanceof是Java中的二元运算符，左边是对象，右边是类；当对象是右边类或子类所创建对象时，返回true；否则，返回false。①左边的对象实例不能是基础数据类型。②左边的对象实例和右边的类不在同一个继承树上。③null用instanceof跟任何类型比较时都是false。
3. a.equals(str) 判断字符串是否相等

5、 包机制

package pkg1[.pkg2[.pkg3...]];

注：一般利用公司域名倒置作为包名

为了使用包成员，需明确导入该包

import package1[.package2...].(classname|*);

*表示导入包下所有的类

6、 《阿里巴巴Java开发手册》

7、 JavaDoc生成文档

JavaDoc命令是用来生成自己的api文档的

参数

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

javadoc -encoding UTF-8 -charset UTF-8 doc.java //java 参数 文件名

8、 输入

① Scanner

Scanner scanner = new Scanner(System.in); //创建扫描器对象，用于接收键盘数据
if (scanner.hasNext()){
	String str = scanner.next();
} //使用next方法接收
scanner.close(); //属于IO流的类不关闭会一直占用资源

Scanner scanner = new Scanner(System.in);
if (scanner.hasNextLine()){
	String str = scanner.nextLine();
} //使用nextLine方法接收
scanner.close();

next()

1. 一定要读取到有效字符后才可以结束输入
2. 对输入有效字符之前的空白会自动删除
3. 输入有效字符后的空格会作为分隔符或结束符
4. 无法得到带空格的字符串

nextLine()

1. 以Enter为结束符
2. 可以获得空白

可以在next()和nextLine()后加入具体数据类型，例如hasNextIne()和nextInt()

② if选择结构

if(布尔表达式){
	命令行;
}else if{
	命令行;
}else{
	命令行;
}

③ switch多选择结构

switch(expression){
	case value:
		(break;)
	case value:
	default:
}

注：

1. case标签必须为字符串常量或字面量

④ 循环结构

while 循环

while(布尔表达式){
	//循环内容
}

do...while 循环

do{
	//循环内容
}while(布尔表达式)；

for 循环

for(初始化;布尔表达式;更新){
	//代码
}

for(声明语句:表达式)
{
	//代码句子
}

9、 方法

修饰符 返回值类型 方法名(参数类型 参数名){
	...
	方法体
	...
	return 返回值;
}

可变参数：必须在所有参数最后，可以输入任意个数的该类型参数

int... i

10、 数组

dataType[] arrayRefVar = new dataType[arraySize];

int[] nums;(优先) 或 int nums[]; //声明
nums = new int[10]; //创建
len = nums.length; //数组长度

arrays类

方法	作用
fill	赋值
sort	升序排列
equals	判断元素是否相等
binarySearch	二分查找
...	...

稀疏数组

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

array[count][3]
array[0][0]=行数
array[0][1]=列数
array[0][2]=不同值的个数
array[i][0]=当前值行数
array[i][1]=当前值列数
array[i][2]=当前值

11、类与对象

一个java类中可以有多个class类，但是只能有一个public class类

public class Student{
    String name;
    int age;
    public void study{
        System.out.println(this.name+"is learning");
    }
} //类

public static void main(String[]args){
    Student a = new Student();  //类实例化
    Student b = new Student();
    a.name = "alpha";
    a.age = 3;
    System.out.println(a.name);
}

构造器

Alt+Insert

1. 和类名相同
2. 没有返回值
3. new 本质在调用构造方法
4. 能初始化对象的值
5. 定义有参构体后，若想使用无参构造，显示的定义是一个无参的构造

abstract 抽象类/方法

public abstract class Main {
    public abstract void Kevarl(); //抽象方法只有名字，没有方法的实现
} //抽象类

抽象方法由继承了该类的非抽象类通过重写实现

注：

1. 抽象类不能被new
2. 抽象类中可以写普通方法
3. 抽象方法必须在抽象类中

内部类

public class Main {
    Outer outer = new Outer();
    Outer.Inner inner = outer.new Inner();
} //通过外部类来实例化内部类

局部内部类：方法内的内部类

注：

1. 内部类可以调用外部类的私有属性

12、 继承

所有的类默认直接或间接继承Object类

extends

创建派生类（子类）

public class Student extends Person{
	//Students是子类，Person是父类
}
也可以写成：
public class Student{
	Person person;
}

子类可以调用父类的公用方法，但不能调用私有

Ctrl+H 打开继承树

this

this.varName 调用当前类所定义的该变量名

没有继承也可以使用

super

super.varName 调用父类所定义的该变量名

super(); //隐藏代码，调用父类的构造器，必须在子类的第一行

只能在继承条件使用

重写

重写是方法的重写，和属性无关，需要有继承关系

@override //快捷键：Alt+Insert

子类重写父类的方法，调用时以子类为准

注：

1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符范围可以扩大 public>protected>default>private
4. 抛出的异常：范围可以被缩小，但不能扩大
5. 无法重写：
   1. static 方法属于类，不属于实例
   2. final 常量
   3. private

13、 多态

同一方法可以根据发送对象的不同而采取多种不同的行为方式

存在条件：

1. 继承关系
2. 方法需要重写
3. 父类引用指向子类

Father f1 = new Son();

注：

1. 多态是方法的多态
2. 对象能执行那些方法主要看左边的类型

instanceof

通过返回一个布尔值来指出，这个对象是否是这个特定类或者是它的子类的一个实例

object instanceof class;

如果 object 是 class 的一个实例，则 instanceof 运算符返回 true。如果 object 不是指定类的一个实例，或者 object 是 null，则返回 false

14、 static 静态

静态变量

public class Main {

    private double a; //非静态变量
    private static double b; //静态变量

    public static void main(String[] args) {
        Main main1 = new Main();

        System.out.println(main1.a);
        System.out.println(main1.b);
        System.out.println(Main.a); //报错
        System.out.println(Main.b);
    }
}

静态代码块

public class Main {

    {
        System.out.println("匿名代码块");
    }

    static {
        System.out.println("静态代码块");
    } //赋初始值
    
    public Main(){
        System.out.println("构造方法");
    } //只执行一次

    public static void main(String[] args) {
        Main main1 = new Main();
        System.out.println("================");
        Main main2 = new Main();
    }
}

/**
结果：
	静态代码块
	匿名代码块
	构造方法
	================
	匿名代码块
	构造方法
*/

静态导入包

import  static java.lang.Math.random;
public class Main {
    public static void main(String[] args) {
        System.out.println(random());
    }
}

等价于：

public class Main {
    public static void main(String[] args) {
        System.out.println(Math.random());
    }
}

15、 接口

作用；

1. 约束
2. 定义方法，让不同的人实现

关键字：interface

public interface Main {
	public static final int age = 99; //接口内定义常量
    void main();
}

public interface More {
    void more();
}

public class UserServiceImp implements Main,More {
    public void main() {
        System.out.println("1");
    }
    public void more(){
        System.out.println("2");
    }
} //通过 类 implements 接口 实现接口内方法的重写

注：

1. 接口中的所有定义其实都是抽象的public abstract
2. 接口可以实现多继承
3. 接口不能被实例化

16、 异常

异常体系结构

Java把异常当作对象处理，并定义了一个基类java.lang.Throwable作为所有异常的

超类

异常处理机制

try{
	// try监控区域
	throw new ThrowableType(); // 直接抛出某类异常
}catch( 异常类型 异常名 ){ // catch捕获异常
	// 处理异常
}catch( 异常类型 异常名 ){
	异常名.printStackTrace(); // 打印错误的栈信息
}finally{
	// 善后,可以不要
}

public void doA(int a) throws Exception1,Exception2{......}

throw语句用在方法体内，表示抛出异常，由方法体内的语句处理
throws语句用在方法声明后面，表示再抛出异常，由该方法的调用者来处理

注：

1. 若要捕获多个异常，需从小到大捕获

快捷键：Ctrl+Alt+T

自定义异常

public class Main extends Exception{
    private int detail;
    public Main(int a){
        this.detail = a;
    }

    @Override
    public String toString() {
        return "Main{" +
                "detail=" + detail +
                '}';
    }
}

类 extends Exception

标签：Java,入门,基础,System,class,println,new,Main,public
From： https://www.cnblogs.com/KevinKarl/p/17565222.html