最基础的Java语言知识

基本的dos命令

cls 清屏
exit 退出
ipconfig 查看本机ip
dir 查看某当前目录文件==ls
md创建文件夹
cd>a.txt文件名即可在当前目录下创建文件
del a.txt删除文件
rd text//删除目录文件夹

基础知识

面向对象，跨平台（win，Linux，mac都能运行）
三大版本：JavaSE标准版，JavaME，JavaEE

Java大小写敏感

顺序结构

从上到下一次执行，是基本结构

Java是值传递

基础语句

文件名和类名必须一直，且首字母必须大写

注意方法名大写

在cmd里面编译javac 文件名.java

java 文件名运行同名的class文件
卒，报错，正在尝试使用较新的 Java 版本编译的类文件（版本 65.0），但运行它的 Java Runtime 环境版本较旧（仅支持到版本 52.0），行吧，我就用idea总行了吧
Java是一种混合型的编程语言，既有面向对象的特征，也有面向过程的特性。

IDEA

语句以分号结尾
ctrl+鼠标左键点击，即可看到方法的用法
Ctrl+d快速复制到下一行
Ctrl+r全局替换
创建空项目

创建一个包，类似于文件夹

文件挪进去之后首行会出现包的名字，这句话不能删除

基础语法

注释
//单行
/*多行注释*/
/**
*文本注释
*
*/
注解，有功能的注释

变量命名规则
只能以大小写数字，$,下划线_开头（不能以数字开头）不能用关键字命名，可以用中文命名
变量必须初始化即赋值后才可以使用

//整数
byte -128~127
short
int
long //long num=30L
//小数
float //float num=50.1F
double
//字符，只有一个字
char
//字符串,不是关键词，是一个类
//string
//布尔值
boolean//true/false
//8位=1字节

引用类型：类，接口，数组
浮点数数据过大，采用二进制进行比较的时候，会有误差，精度不同比较也是不等

强制类型转换

char c='a';
System.out.println((int)c);
//unicode编码
//U000~UFFF

要避免内存溢出，高到低
不能对布尔值进行转换
自动转换，低到高，不需要括号

例如
int a=10;
byte b=(int)a;

变量

类变量

static开头，写在类里面

实例变量

没有关键字开头，不用初始化
会默认初始值：0，0.0，null，false，(u)00000字符串

局部变量

写在方法里面的

常量

final关键字，修饰符，不区分前后顺序
final 常量名=常量值，常量名大写
static final int PI=3.14;
驼峰命名：第一个单词小写，后面的单词首字母大写

运算符

算数运算符
赋值运算符=
关系运算符==
逻辑预算符&&,||,!
位运算符:&,|,^,~,>>,<<,>>>
A&B:二进制，都为1才是1
A|B：都是0，才是0，否则为1
A^B:相同0，不同1，异或
~B：取反
<< *2//即1往左移位
>>/2//1往右减小
条件运算符?:
扩展赋值运算符：+=，-=，*=/=
幂运算Math.pow(2,3);//2^3

//字符串链接
System.out.println(a+b);//输出为数字相加
System.out.println(""a+b);//输出为ab字符拼接
只要有一方是字符，都会转化为字符拼接

包机制

本质是文件夹，用于区别命名空间
package java.lean//分级，必须在第一行
import aaa.*;导包，导入所有类，需要在package下面

JDK7特性

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

1	int money=10_0000_0000

流程控制

用户交互Scanner

Jdk5出现的

package learn;

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {

        //创建一个对象用于接受数据
        Scanner scanner= new Scanner(System.in);

        if(scanner.hasNext()){//判断用户是否还有下一个输入
            String word = scanner.next();
            System.out.println(word);

            scanner.close();//避免占用资源
        }

    }


}

通过next()和nextLine()输入数据，通过hasNext()和hasNextLine()判断是否有数据输入
next()空格会作为结尾，输入有效字符前存在的空白会自动截取掉，nextLine()则以enter结尾
可选输入类型

非顺序结构

if选择语句
Switch

char aaa='c';
swich(a){
    case'a':
    System.out.printlen("优秀");
    break;
    case'b':
    System.out.printlen("良好");
    break;
    case'c':
    System.out.printlen("及格");
    break;
}

swich穿透，没有break会一直往下走
从jdk7开始支持字符串了
While
DoWhile
For Jdk5以后出现增强型for循环,呢个够在数组里面进行循环

       int[] numbers = {10, 20, 30, 40};
       for(int x:numbers){
           System.out.println(x);
       }

idea快捷语句5.for+Tab

最终输出

break，continue，goto

基本相同，避免使用goto语句

int[] numbers = {10, 20, 30, 40};
   table:for(int x:numbers){
       System.out.println(x);
       if(x%3==0){
            continue table;
       }
   }

方法

静态与非静态

static加了就是静态，不加就是非静态，
在同一个类里可以类名.方法名调用

非静态，要把类实例化之后，才可以类名.方法调用

静态方法是与类一起加载的，而动态方法只有实例化了之后，才存在

类比php，python里面的方法，idea快捷键psvm快速创建一个方法

package learn;

import java.util.Scanner;

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

    public static int aaa(int a,int b){
        return a+b;
    }

}

类里面不需要提前去声明

1
2
3

修饰符 返回值类型 方法名（参数类型，参数名）{
    功能，内容，参数名可有可无
}

形参，实参

重载

在一个类里面有相同的函数名称，但形参不同的函数，（类型，数量不同）
即当返回值类型，或者参数数量，类型不同时，代码能够识别同名方法

命令行传参

运行的时候再传递消息

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

我的命令行目前跑不了这个，视频里面截的，到时候弄好再换

可变参数

Jdk1.5之后，也叫不定项参数
再方法声明中，再指定参数类型后加一个省略号
一个方法只能指定一个可变参数，它必须是方法的最后一个参数，任何普通方法必须在这之前声明

package learn;

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Main main = new Main();
        main.texxt(1,2,3,4,5,6);
    }
    public void texxt(int...i) {
        System.out.println(i[0]);
        System.out.println(i[1]);
        System.out.println(i[2]);
        System.out.println(i[3]);
        System.out.println(i[4]);
    }


}

返回值

递归调用

跟其他的语言差不多，理解递归是什么就可以了

反编译

IDEA支持将class文件反编译为能够看的代码，通过idea打开class文件即可

数组

是引用类型
使用数组必须要先声明数组类型，长度在创建的时候就已经固定了
数组对象本身保存在堆中

int[] nums;//首选
int nums[];

int[] nums;//声明数组
nums=new int[10];//创建一个数组

int[] nums = new int[10];
nums.length可以获得变量长度
赋值nums[0]=1;根据下标找到
默认值时0//就前面说过的默认值

数组：

//静态初始化：创建+赋值
int[] a ={1,2,3,4,5,6}
//引用类初始化
Man[] mans ={new Man(),new Man()};

数组打印方法

public static void pr(int[] arry){
    for(int i=0;i<arry.length;i++){
        System.out.print(arry[i]+" ");
    }
}

下标越界

超过区间了
int[] num=new int[10];
当我们访问num[10]时就会报下表越界的错误
ArrayIndexOutofBounds

二维数组

//动态
int[][] nums=new int[2][2];
//静态
int[][] arry={{1,2,3},{2,3,4}}

arry.length得到的时第一维的数量

Arrys类

相当于include之后就能调用string方法了

public static void main(String[] args) {
    int[] arr = new int[10];
    System.out.println(arr);
}

调用类打印
    public static void main(String[] args) {
        int[] arr = new int[10];
        System.out.println(Arrays.toString(arr));
    }

Array.sort(arr)//自动排序
fill赋值
equals//比较是否相等
binarySearch//二分法查找

稀疏数组

就类似于数据结构吧，存储坐标和值，数组下标代表坐标，赋值即为值

面向对象编程

方便调用，减少重复

创建

new关键字创建，分配空间，默认初始化，对构造器的调用
类里面只有属性和方法

构造器

快捷键Alt+Inert；
一个类即使什么都不写，也会存在一个构造器。
构造器也称构造方法，实在进行创建对象的时候必须要调用的,特点：必须和类的名字相同，必须没有返回值，也不能写void

类似于php里面的construct方法，在实例化的时候会调用，new的时候必须要有

作用：赋给对象初始值

当有一个同名的有参类构造，系统就不会默认生成无参构造，需要自己手动的把无参构造给打出来

封装

“高内聚，低耦合”：内部细节自己完成，仅需暴露少量的方法额给外部使用。
封装就是属性私有，提供一个公共的方法获取数据
private：私有属性

输出为20
封装能够限制和规范一些用法

继承

类和类之间的关系，还有依赖，组合，聚合等
父类和子类

extend

子类继承了父类，就有父类的所有方法
private属性无法继承，protected可以继承
CTRL+h，可以查看到了的关系树
在Java中所有的类都默认继承Object类，只有单继承，没有多继承，类似树的结构

super关键字

代表父亲的
只能出现在子类方法或者构造方法中
this能调用自己的成员，super能够调用父亲的
子类的构造器会默认调用父类的构造器，显示调用即把隐藏代码super();写出来的话，需要把代码放在子类的第一行
如果父类的构造器是有参的话，子类也需要显示的有参调用

方法重写

父类不能调用子类独有的方法，要想调用就要强制转换成子类发类型

1
2
3

父类Father，子类Ch
Father gcc=new Ch();
((Ch) gcc).get;

重写都是方法的重写，和属性无关。
就是继承关系中，当调用子类的方法时，
静态方法：
方法的调用只和定义的数据类型有关
父类的引用指向了子类

1 2	父类Father，子类Ch Father gcc=new Ch();

非静态的方法
子类重写了父类的方法

1 2	@Override, //重写父类的方法

方法名，参数列表相同
修饰符范围可以扩大：public>protect>privated
抛出异常范围可以被缩小但是不能扩大
功能：
父类的方法子类不一定需要或者不一定满足
Alt+Insert：override；

多态

一个对象的实例类型是确定的，但是引用类型就是不想确定的了
多态是方法的多态，是继承关系，方法需要重写

1
2
3

static
final
private

实例化的时候，左边决定方法，右边决定用哪个构造器来进行初始化

引用类型转换

instanceof 关键字，用于判断两个类之间是否是父子关系。

同级或者没有继承关系，就会报错

Father gcc=new Ch();
高转低，即父转成子，需要使用强制转换
低转高自动转
父转子
((Ch) gcc).get
子转父
Ch aa=new Ch();
Father fa=aa;

static


public class Main {

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

    static {//只执行一次
        System.out.println("静态代码块");
    }

    public Main() {
        System.out.println("构造方法");
    }

    public static void main(String[] args) {

        Main main = new Main();

        System.out.println("=============");
        Main main2 = new Main();
    }



}

输出顺序：

匿名方法块可以用来赋予初始值

抽象类

abstract修饰符，约束
抽象类，抽象方法，抽象类的子类继承后必须重写父类的抽象方法，除非子类也是抽象类
不能new抽象类
抽象类里面可以有正常的方法，抽象方法只能出现在抽象类里面

接口

只有规范，自己无法写方法，专业的约束，实现约束与实现分离，面向接口编程，本质是契约

interface关键字

接口中的所有方法定义都是抽象的public abstract
所有属性默认常量 public static final
接口不能被实例化，没有构造方法
必须要重写接口的方法
接口都需要有实现类，一般会用Impl结尾

重写后就不会报错了

接口可以同时有很多个

内部类

成员内部类
静态内部类
局部内部类
匿名内部类

通过外部类来实例化内部类

内部类可以获得外部类的私有属性，类型要一致，静态方法无法获取非静态私有属性

一个Java文件里面只能有一个public class大类，但是可以有多个class文件

局部内部类

public class Outer{
    public void out(){
        class Inner{
            
        }
    }
}

匿名内部类，没有名字初始化类

public class Main{
    public static void main(String[] args){
        new A().eat();
    }
}
class A{
    public void eat(){
        System.out.println("1");
    }
}

匿名接口

public class Main{
    public static void main(String[] args){
        new A(){
            @Override
            public void eat(){
                System.out.println("1");
            }
        };
    }
}
interface A {
    public void eat();
}

异常机制

Exception
检查性异常，运行时异常，错误
异常等级：

抛出，捕获，处理

try、catch、finally、throw、throws

public class Main{
    public static void main(String[] args){
        try{
            System.out.println(1/0);
        }catch(ArithmeticException e){//catch（想要捕获的异常类型）
            System.out.println("Arithmetic Exception");
        }finally {
            //可以不要，一般用于IO流，资源关闭
            System.out.println("Finally");
        }
    }
}

也支持写多个catch，只会生效且其中一个，和if，else if一样，但是捕获的异常需要从小到大的写，否则会报错
快捷键：选中后Ctrl+Alt+T

主动抛出异常

if (b==0){
    throw new ArithmeticException();
}

一般会在方法里面
throws，无法解决，往上抛出

自定义异常

package learn.Erro;

public class Text {
    static void text(int a) throws MyException{
        System.out.println("参数为"+a);
        if(a>100){
            throw new MyException(a);//抛出异常
        }
        System.out.println("OK");
    }

    public static void main(String[] args) {
        try {
            text(1);
        } catch (MyException e) {
            throw new RuntimeException(e);
        } finally {
        }
    }
}

package learn.Erro;

public class MyException extends Exception{

    private int code;
    public MyException(int a){
        code = a;
    }

    //异常的打印信息
    @Override
    public String toString() {
        return "MyException{" +
                "code=" + code +
                '}';
    }
}

JavaDoc生成文档

cmd生成

idea生成

打开刚刚存储的文件

能够看到生成了，并且也自动弹出了网页

总结

还没完，但是我要先总结，IDEA简直就是神器