第一阶段：狂神说——javaSE(基础)

声明：本文章只是用于自己的知识补全。笔者java有点基础，但不多，所以会有一些简单的知识就不写了

一、计算机硬件部分之冯诺依曼体系结构

这是计算机硬件部分

二、 计算机软件部分之系统软件和应用软件

• 系统软件
  DOS（磁盘操作系统）,Windows,Linux,Unix,Mac,Android,iOS
• 应用软件
  WPS,QQ,微信等
  人机交互指图形化界面，命令行

三、Windows常用快捷键

• Alt+f4关闭窗口
• shift+del永久删除文件
• window+r直接打开输入cmd的命令窗口
• window+e直接打开文件夹

四、常用的dos命令

dos命令，就是cmd的那个黑框里面输入命令

• E:即切换到E盘
• 查看当前目录下的所有文件，dir
• 通过cd来切换目录
  切换到不同的盘，cd /d+盘符名，如cd /d f:,返回上一级，cd ..,访问同级目录下，cd 文件名
• 清屏 , cls
• 退出终端,exit
• 查看电脑ip，ipconfig
• 打开电脑计算机，calc
• 打开画图工具，mspaint
• 打开一个新建的记事本，notepad
• 可以通过ping +网站地址查看网站的ip信息
• 在桌面新建一个目录，md+目录名
• 创建一个文件cd>+文件名，此处不用加空格
• 删除文件，del+文件名
• 移除目录，rd +目录名

五、 java的特性和优势

简单性，面向对象，可移植性，高性能，分布式，动态性，多线程，安全性，健壮性

六、java三大版本

• javaSE（是核心）：标准版（桌面程序，控制台开放）
• javaME（简单了解）：嵌入式开发（手机，小家电）
• javaEE（掌握）：企业级开发（Web端，服务器开发）

七、JDK，JRE，JVM

• JDK：java开发工具
• JRE：java运行时环境
• JVM：java虚拟机
  它们之间的关系，下载jdk之后就能进行正常开发了，因为jdk包含了其他两货

八，java的基础语法

• 注释。单行注释：//，多行注释：/代码块/，文档注释(javadoc)：/** */
• 标识符和关键字。
  不能以数字开头！
• Java数据类型
  
  字节科普：
  二进制0b，八进制0，十六进制0x。010为8
  关于浮点数，银行业务通常不用float和double来表示钱，而是利用BigDecimal数学工具类来表示。所有的字符本质上还是数字，即字符可被强制转换为数字，(int)a。转义字符：\t制表符，\n换行符…
• 数据类型转换：
  数据类型强度由低到高依次为：byte,short,char->int->long->float->double
  低转高自动转换，高转低强制转换。不能对布尔值进行转换，在计算比较大的数字的时候注意溢出的问题。，把小的转成大的
  变量作用域：
• 类变量：static声明,从属于类
• 实例变量：类的里面，方法的外面，从属于类。如果未进行初始化，数值默认为0，布尔默认为false，其他为null
• 局部变量：定义在方法里面
  
  Java中的常量定义：
  常量，就是定义后不能改变它的值。定义方式：final 常量名 = 值。如final double = 3.14,常量名一般使用大写字符。
• 运算符

public class Demo01 {
    public static void main(String[] args) {
        int a = 3;
        int b = a++;
        int c = ++a;
        System.out.println(a);//输出5
        System.out.println(b);//输出3
        System.out.println(c);//输出5
    }
}

   //位运算符
    /*
      A = 10011001;
      B = 00100011;
      A&B = 00000001  与运算
      A|B = 10111011; 或运算
      A^B = 10111010 异或，相同为0，否则为1
      ~B = 11011100 取反
      左移和右移运算符,二者直接接触底层，效率极高
      左移：<<
      右移：>>
      2*8=16的最快运算速度为2<<3
      原理：0000 0010  值为2,使用左移运算符2<<3之后，相当于
           0001 0000  这不就是16的值了吗
      
    */

public class demo02 {
    public static void main(String[] args) {
        int  a = 10;
        int b = 20;
        System.out.println(""+a+b);//1020
        System.out.println(a+b+"");//30
    }
}

• Java的包机制
  所说的用公司的域名倒置作为包名，例如，百度为www.baidu.com，在开发中我们就这么建包：com.baidu.www。中间还可以添加其他的东西。最终可以得到一个这样的目录结构：
  
  可以通过impore 需要的位置.*导入所有类
• JavaDoc命令
• 用户交互Scanner
  java提供了这样的一个工具类用来实现获取用户的输入，即java.util.Scanner，我们可以通过Scanner类来获取用户的输入。语法：

Scanner  s = new Scanner(System.in);

通过Scanner类的next()与nextLine()方法获取输入的字符串，在读取前通常需要hasNext()与hasNextLine()判断是否还有要输入的数据。system.in指接受用户的输入。（其实可以不要if的判断）实例：

public class Demo01 {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);//创建扫描器，用来接受输入
        System.out.println("请输入：");//提示输入
        if(s.hasNext()){//判断用户是否还有输入
            String str = s.next();//定义一个变量用来接受
            System.out.println("输出的内容为："+str);
        }
        s.close();//使用完成一定要关掉这个IO流,不然会占用资源
    }
}

next()和nextLine()的区别：
总之，使用nextLine()可以获取所输入的完整字符串，使用next()如果输入的字符串中间有空格获取的字符串则会断开。于此之外，还有nextFloat(),nextInt()等等。
接下来上手一个小案例：

public class Demo02 {
    public static void main(String[] args) {
        //我们输入多个数字，并求其和与平均数，每输入一个回车确认，输入非数字代表结束并输出结果
        Scanner s = new Scanner(System.in);
        double sum = 0;
        int x=0;
        while(s.hasNextDouble()){
            sum+=s.nextDouble();
            x++;
        }
        System.out.println("总和为：="+sum);
        System.out.println("平均数为："+(sum/x));
        s.close();
    }
}

• switch分支结构小案例：

 public class Demo03 {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        switch (s.nextInt()){
            case 100 :
                System.out.println("优秀"); break;
            case 80 :
                System.out.println("良好"); break;
            case 50 :
                System.out.println("不及格");
        }
        s.close();
    }
}

while循环和do while()循环的区别在于，do while至少执行一次。
for循环语法格式如下：for(初始化;布尔表达式;更新){}
for循环打印九九乘法表：

public class Demo05 {
    public static void main(String[] args) {
        //打印九九乘法表
        int x=0;
        for(int i=1;i<=9;i++){
            for(int j=1;j<=i;j++){
                x=i*j;
                System.out.print(j+"*"+i+"="+x+"\t");
            }
            System.out.println("\n");
    }
    }
}

• 增强for循环，主要是用来遍历数组集合之类的，格式：

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

例如，遍历一个数组：

public class Demo05 {
    public static void main(String[] args) {
      //循环遍历并输出数组
        int[] numbers = {1,2,3,4,5,6};
        for(int x:numbers) {
            System.out.println(x);
        }
    }
}

打印等腰三角形：

public class Demo05 {
    public static void main(String[] args) {
      //打印一个三角形
        for(int i=1;i<=5;i++){
            for(int j=5;j>i;j--){
                System.out.print(" ");
            }
            for(int j=1;j<=i;j++){
                System.out.print("*");
            }
            for(int j=1;j<i;j++){
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

• java流程控制之break,continue
  break用于终止循环，而continue用于跳出本次循环，执行下一个，不终止循环。

• 方法的定义：
  使用void修饰的方法，对它的调用是一条语句。如在public static void main(String[] args) 当中直接调用System.out.print(" ");输出方法。

• 方法的重载
  定义：就是在同一个类当中，有相同的函数名称，但形参不同的函数。

• 命令行传参
  当你想要在一个程序运行的时候再给它传递消息，这时候需要通过传递命令行参数给main()函数实现。
  可变参数：在方法的声明中，在指定的参数类型后面加一个省略号，且它必须是方法的最后一个参数。例如：public void test(int... i){ //代码体}然后在调用的时候可以传递多个参数。如s.test(1,2,3,4,5)

• 递归
  递归的解释就是函数内部调用自己本身。实例如下：

 public class Demo06 {
    public static void main(String[] args) {
        Demo06 s = new Demo06();
        System.out.println(s.f(5));
    }
    public  static int f(int n){
        //求阶乘
        if(n==1){
            return 1;
        }else return n*f(n-1);//这里调用自己本身
    }
}

• 数组的声明与创建
  对于数组的声明，有两种方法：

 1.数据类型[]  数组名-----int[] nums;//(首选)
 2.数据类型  数组名[]-------int  nums[];

定义完成之后需要使用new关键字来创建数组：

int[] nums = new int[10];//定义了一个长度为10的数组

数组下标从0开始，此时数组的所有值都是初始值0，只是在堆里面开辟了一个空间,可以直接在数组里面放入值。

int[] nums = {1,2,3,4,5}

• java的内存分析：
  数组对象本身是在堆中的
• 数组的使用
  1.for-each循环

public class Demo07 {
    public static void main(String[] args) {
        //for-each遍历数组
        int[] a = {1,2,3,4,5,6};
        for (int x:a) {
            System.out.println(x);
        }
    }
}

2.数组可以封装成为参数：

public class Demo07 {
    public static void main(String[] args) {
        //for-each遍历数组
        int[] a = {1,2,3,4,5,6};
      printArrys(a);
    }
    public static void  printArrys(int[] arry){
     //打印数组元素
        for(int x:arry){
            System.out.println(x);
        }
    }
}

• 二维数组的定义
  与一维数组类似：

 int[][] a = new int[2][5]//定义了一个2行5列的数组
 int[][] a = {{1,2},{3,4},{5,6},{7,8}}

二维数组的遍历：

public class Demo07 {
    public static void main(String[] args) {
        //for-each遍历数组
     int[][] a = {{1,2},{3,4},{5,6},{7,8}};
     for(int[] x:a){
         for(int y:x){
             System.out.print(" "+y);
         }
         System.out.println();
     }
    }
}

java提供了一个Arrays工具类，在这个类中定义了许多方法，如sort()排序方法，使用时需要先在顶部导入import java.util.Arrays
Array.toString()可以将对象转换成为数组，例如：

int[] a= {1,2,3,4,5};
System.out.println(a);//打印出来的是一个对象
System.out.println(Arrays.toString(a));//打印出来的是一个数组[1,2,3,4,5]

Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用而不是使用对象来调用。
Arrays通常具有以下功能：
给数组赋值：通过fill方法。
对数组排序：通过sort方法，是升序。
比较数组：通过equals方法比较数组中元素是否相等
查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作

面向对象

• 什么是面向对象
  

• 面向对象的三大特性
  
  面向对象编程简称OOP。
  一个项目应该只有一个main方法，尽量不要定义在类里面，给它写出去
  
  字符串String的默认值为null，数据类型的值默认为0

• 构造器
  
  构造器的核心：
  1.使用new关键字实例化一个对象的时候本质是调用了一个构造器，这个构造器是隐士定义的。
  2.一旦定义了有参构造，无参构造必须显示定义，使用构造器是用来初始化值的
  
  使用Alt+insert可快速生成构造器

• 封装
  封装的本质是使用private关键字对类中的属性进行私有定义，这样，在main()函数中实例化的对象就不能进行访问private修饰好的属性了，若想访问，需要在类中定义get获取/set设置方法，get和set方法自定义
  
  

• 继承
  java中子类继承父类使用关键字extends，子类可以继承父类中除private修饰的所有属性和方法。继承中的重点是super和方法重写
  super与this做对比，通过super可以访问父类中的属性和方法，但是不能调用私有的属性和方法。 中间student子类自上而下的name分别指参数中的name，student中的name，父类中的name,
  子类中的第一行有一个隐式的super()方法调用父类的构造器

• 方法的重写
  只存在于继承关系当中，且重写的方法为非静态方法，而被重写的方法在子类中方法上部会有一个@override修饰，即表明这是一个方法的重载

 public  class  A extends  B{
 @override
 public  void test(){
      System.out.println("A");
   }
}
 public  class B{
 public  void test(){
      System.out.println("B");
   }
}

然后在main()方法中A a = new A();a.test()就成功重写父类的方法啦

• 多态
  
  
  
  类型转换：
  public class Father{
  public void test(){
  System.out.println(“father”);
  }
  }
  public class Child extends Father{
  public void run(){
  System.out.println(“child”);
  }
  }
  类型转换就是父类转子类需要强制转换，子类转父类不需要强制转换。
  在main()方法当中，我们实例了一个父类型的father对象，然后想调用子类的run()方法，Father father = new Father();father.run()，但是这是不行的，需要对father进行强制转换，Father father = new Father();((Child)father).run()，把father对象强制转换成子类对象，这样就能成功调用子类的run()方法。
  static代码块：static{//代码体}只执行一次，且优先执行；通过final修饰的类不能有子类。被static修饰的变量可以通过类名.属性的方式访问：

//此处仅做演示
public class student{
     private static int age;
     private int score;
     student.age//可以访问到
     student.score//不可以访问到
}

• 抽象类
  
  记住，是在子类里面重写它的方法，即方法上面有个@override，一般用不到抽象类，而是用到接口。
• 接口interface
  
  接口的本质是一个比抽象类还要抽象的类，通过

public interface demo{
      public  void add(String name);
      public  void delete(String name);
      public  void modify(String name);
      public  void search(String name);
}

就定义了一个接口,但是一个接口通常具有一个实现类，因为它里面的方法不能直接实现，而建立的实现类的文件名后为Impl，即还需定义一个实现类

public class demoImpl implements  demo[,接口二]{//这样就可以实现多继承
    @overrid
    public void add(String name){};
    ...
}

内部类

public class Outer{
   private int id=10;
   public void  out(){
      System.out.println("这是外部类的方法");
   }
   public class Inner{
      public void in(){
           System.out.println("这是内部类的方法");
     }
      public void getId(){
           System.out.println(id);
     }
  }
}

//然后在main函数中定义内部类的时候是这样定义的。
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
inner.getId();//获取到外部类中的私有属性id

内部类可以获得外部类的私有属性，但是如果内部类被static修饰的话就拿不到id了，此时就是静态内部类
一个java文件中只能有一个public类，但可以有多个class类，此时定义的匿名内部类，这时就不用将实例保存到一个变量中，还可以定义接口。

public class Outer{
   public static void main(String[] args){
          new Outer().eat();//不用将实例保存到一个变量中
          B b = new B(){
          @overrid//需要重写方法
          public void hello(){
              }
          }
      }
   }
   class A{ 
      public void eat(){
         System.out.println("吃了");
      }
   interface B{
       void hello();
      }
   

如果是在一个方法中定义一个类，那就是局部内部类。

public class Outer{
   public void  out(){
       class  A{//局部内部类
       }
   }

异常

java的异常体系：

• 异常处理机制

第一种，直接捕获异常并处理。

public class Demo07 {
    public static void main(String[] args) {
     //处理异常
        int a = 3;
        int b = 0;
        try{
            System.out.println(a/b);//捕捉异常
        }catch (ArithmeticException e){//异常类型
            System.out.println("分母不能为0！");
        }finally {//最终的步骤
            System.out.println("成功捕获异常！");
        }
     }
    }

第二种，主动抛出异常并处理，一般在方法当中使用，即假设这个方法处理不了这个异常，那就需要把这个异常给抛出去，让更高级来处理它，方法里面抛出是throw，方法外部是throws，当你应用了try catch捕获之后程序就会继续执行，否则就会终止

public class Demo07 {
    public static void main(String[] args) {
     //处理异常
        int a = 3;
        int b = 0;
     Demo07 demo07 = new Demo07();
     try {//既然抛出了就要捕获是不
         demo07.test(1,0);
     }catch (ArithmeticException e){
         System.out.println("成功捕获异常");
     }
    }
    public void test(int a,int b) throws ArithmeticException{
        if(b==0){
            throw new ArithmeticException();
        }
    }
}

• 自定义异常
  
  自己定义了一个异常：

public class MyException extends Exception{
    //传递数字，如果大于10就抛出异常
    private int detail;
    public MyException(int a){//需要写一个构造器
        this.detail = a;
    }

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

然后定义一个测试类来捕获异常：

public class Test {
    public static void main(String[] args){
        try{//监听会有异常的语句
            test(14);
        }catch (MyException e){//捕捉异常
            System.out.println("异常信息为："+e);
        }
    }
    //可能会存在异常的方法
    static void test(int a) throws MyException{
        System.out.println("传递的参数为："+a);
        if(a>10){
            throw new MyException(a);//抛出
        }
        System.out.println("成功接收参数");//打印出来的话就成功捕获异常，程序没有终止嘛
    }
}

javaSE基础，完结撒花！