【Java基础内容总结】Java基础看这个就足够了

一、创建第一个工程

打开Eclipse，创建HelloWorld程序

打开Eclipse选择菜单 File --> New --> Java Project新建工程
填写工程名称为HelloWorld
右键工程名创建类
输入代码


public class HelloWorld {

  public static void main(String[] args) {
    System.out.println("Hello World");
    // TODO Auto-generated constructor stub
  }

}


右键运行

运行结果显示


二、Java基本数据类型



char size = 16
char min = 0
char max = 65535
char default = 0
byte size = 8
byte min = -128
byte max = 127
byte default = 0
short size = 16
short min = -32768
short max = 32767
short default = 0
int size = 32
int min = -2147483648
int max = 2147483647
int default = 0
long size = 64
long min = -9223372036854775808
long max = 9223372036854775807
long default = 0
float size = 32
float min = 1.4E-45
float max = 3.4028235E38
float default = 0.0
double size = 64
double min = 4.9E-324
double max = 1.7976931348623157E308
double default = 0.0
max int = 2147483647
max int to short = -1
max int to long = 2147483647
max int to float = 2.14748365E9
max int to double + 2.147483647E9
max int = 2147483647
max int + 1 = -2147483648
min int = -2147483648
min int - 1 = 2147483647
max double = 1.7976931348623157E308
max double + max double = Infinity
- max double = -1.7976931348623157E308
- max double - max double = -Infinity
boolean value = true
int i/j = 1
double i/j = 1.0
double (double)i/j = 1.2
double i*1.0/j = 1.2


三、Java的基本流程控制语句
1、If-else
if-else语句主要是根据if的判断结果，选择不同的分支路径，可以if-else嵌套，也可以单独使用if语句，还可以使用 if-else if-else if-…-else进行嵌套

public static void testIfElse(int num) {
    System.out.println("num = " + num);
    if(num < 10) {
      System.out.println("num < 10");
    }
    
    if(num < 100) {
      System.out.println("num < 100");
    }else {
      System.out.println("num >= 100");
    }
    
    if(num < 50) {
      System.out.println("num < 50");
    }else if(num>=50 && num <100) {
      System.out.println("num>=50 && num<100");
    }else {
      System.out.println("num > 100");
    }
  }


2、Switch
当需要判断的条件比较多时会出现很多的if-else，这种代码的可读性比较差，所以我们可以选择使用switch语句

public static void testSwitch(Color color) {
    switch (color) {
    case RED:
      System.out.println("color is " + Color.RED);
      break;
    case GREEN:
      System.out.println("color is " + Color.GREEN);
      break;
    case BLACK:
      System.out.println("color is " + Color.BLACK);
      break;
    case YELLOW:
      System.out.println("color is " + Color.YELLOW);
      break;
    default:
      break;
    }
  }


3、For
for循环是依靠三个字段达到循环的目的，三个字段分别是初始值，结束条件，游标移动。也就是设置一个初始条件，每次循环进行一次游标移动，当达到结束条件时推出循环。

public static void testFor() {
    int[] array = new int[10];
    for(int i=0;i<10;i++) {
      array[i] = i;
    }
    
    for(int j:array) {
      System.out.print(j+" ");
    }
  }


4、While
while语句是循环语句的另一种方式，当while后面的条件成立时继续循环，当条件不成立是时退出循环，也可以使用do-while嵌套，在do后面首先执行一次循环再到while中进行循环是否继续的检测。

public static void testWhile() {
    int[] array = new int[10];
    int i = 0;
    while(i<array.length) {
      array[i] = i;
      i++;
    }
    
    int j = 0;
    do {
      System.out.print(array[j]+" ");
      j++;
    } while (j<array.length);
  }


5、Break 和 Continue
在循环中都起着很重要的作用，其中break语句用于结束循环体也就是退出本层循环，continue语句用于结束本次循环也就是退出本次循环进行下一次循环。

public static void testBreakAndContinue() {
    int[] array = new int[10];
    for(int i=0;i<10;i++) {
      array[i] = i;
    }
    
    for(int j:array) {
      if(j == 3) {
        continue;
      }
      if(j == 6) {
        break;
      }
      System.out.print(j+" ");
    }
    
  }


6、Return
return语句可以退出当前方法，并且可以带返回值void类型的方法返回值会有一个隐式的return作为函数的返回，除了finally特例之外，return后面的语句不会被执行

public static void testReturn(int num) {
    System.out.println("testReturn start*******");
    if(num == 1) {
      return;
    }else if(num == 2) {
      try {
        System.out.println("testReturn try *******");
        return;
      } finally {
      // 此处的语句虽然在return语句后面但是依然会被执行。
        System.out.println("testReturn finally*******");
      }
    }
    System.out.println("testReturn end*******");
  }


四、对象

我们将生活中的任何东西都可以抽象成对象，比如手机抽象成对象，那么手机的硬件如电池、系统、屏幕等就是对象里的字段；而具体的打电话，打短信，逛淘宝就是对象里的方法。面向对象的核心其实就是把任何事物都能够抽象成对象类，这个事物具备的能力就是对象的方法，事物具备的实际事物就是抽象出来的字段。

public class Student {
  // 对象公共字段
  private int age = 24;
  private String name = "HARRY";
  
  private static int count = 0;
  
  public static int getCount() {
    return count;
  }
  
  、、
  public int getAge() {
    return age;
  }
  public void setAge(int age) {
    this.age = age;
  }
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
  
  public Student(int age,String name) {
    count++;
    this.age = age;
    this.name = name;
  }
  
  public Student() {
    count++;
    this.age = 0;
    this.name = "HARRY";
  }
五、方法

通俗的说，方法就是一个函数体实现某种功能的模块，方法中重要的有四个部分：

返回值：就是方法实现功能或者运行之后返回的内容，使用return返回，默认空返回值

方法名：方法的名称，也就是函数名，可是使用某些关键字修饰方法从而实现其他功能

参数：调用方法时所传入的参数，在方法名后面的括号内标记

方法体：方法的具体实现

类调用之前会进行初始化，我们使用构造器实现，构造器就是与类名相同并且没有返回值的方法，并且构造器是可以有多个的，并且参数可以不同。

public class Student {
  // 类名是Student
  private int age = 18;
  private String name = "todo";
  
  // 第一个构造器
  public Student(int age,String name) {
    count++;
    this.age = age;
    this.name = name;
  }
  
  // 第二个构造器，这是无参数构造器必须有，否则无法正确编译
  // 因为默认的构造器没有自动生成
  public Student() {
    count++;
    this.age = 0;
    this.name = "todo";
  }
六、访问权限

java有4种访问权限，分别是公开访问权限，保护访问权限、包含访问权限、私有访问权限

权限名称

关键字

权限范围

用法

公开访问权限

public

所有类都可以访问

一些希望别人使用的方法或者公开的API

保护访问权限

protected

派生子类可用

不希望所有人都可以使用，但派生子类可用或者更改

包访问权限

default

默认访问权限无关键字

限于同一包内，仅希望同一个包里的其他类使用

私有访问权限

private

仅自己类内部可用

类里的方法完全私有，只能类内部使用

七、继承和多态

继承是指派生类基于基类的一种针对属性或者行为的继承，从而拥有基类相同的属性或行为。
多态指的是派生类在基类的基础上进行重写，从而能够表现出不同的性状的特性。

1、toString()继承和重写实践


public class Person {
  public long id;
  public String name;
  public Eyes eyes = new Eyes();
  // 创建一个眼睛的类
  
  // 创建person的构造器
  public Person(long id, String name) {
    this.id = id;
    this.name = name;
  }

  // 对toString进行重写
  @Override
  public String toString() {
    return "id = " + this.id + " name = " + this.name;
  }

  // 对equals进行重写
  @Override
  public boolean equals(Object obj) {
    if (obj == null) {
      return false;
    }
    Person person = (Person) obj;
    if ((this.id == person.id) && (this.name == person.name)) {
      return true;
    }
    return false;
  }
  
  public static class Eyes {
    public String left = "zuoyan";
    public String right = "youyan";
  }

  // 使用main函数调用实现某些功能
  public static void main(String[] args) {
     //创建一个xiaonming的实例1
    Person person1 = new Person(1, "xiaoming");
    //创建一个xiaonming的实例2
    Person person2 = new Person(1, "xiaoming");
    //输出实例1和实例2的对比使用等号表示计算两个实例的地址是否一致
    System.out.println("person 1 == person 2 = " + (person1 == person2));
    // 输出实例1和实例2使用equals函数的计算结果，实例使用的equals是重写之后的函数
    System.out.println("person 1 equals person 2 = " + (person1.equals(person2)));
  }
}


2、多态
首先我们创建一个动物的基类

public class Animal {
  public int weight;
  
  public Animal(int weight) {
    this.weight = weight;
  }
  
  public void move() {
    System.out.println("animal can move!");
  }
  
  public void eat(){
    System.out.println("animal can eat!");
  }
}
然后对基类进行继承

// 对Animal 进行继承
public class Tiger extends Animal{
  public String roar = "ao";
  
  public Tiger(int weight,String roar) {
    super(weight);
    this.roar = roar;
  }
  // 对move方法进行重写之后就表现出类多态的特性从而构成老虎
  // 这里重写成其他内容 如gegege就变成了鸡
  @Override
  public void move() {
    System.out.println("tiger can run!");
  }
}


3、接口
java不能通过多重继承来引入更多的功能，并且又无法将一些能力全部都封装在基类object中，所以我们就需要通过接口来实现一些针对众多 实例的一些通用能力。

4、抽象类
简单描述抽象类就是不可以创建实例的基类，使用abstract描述。在抽象类中可以定义抽象的方法，也是使用abstract描述在方法名前，方法就不需要再基类中实现，而在派生类中必须实现抽象的方法否则就会报错，这样就避免了创建一些没有意义的派生类。

public abstract class Animal {
  public int weight;
  
  public Animal(int weight) {
    this.weight = weight;
  }
  
  public void move() {
    System.out.println("animal can move!");
  }
  
  public abstract void eat();
}
八、容器

容器是存放对象的区域，当大量的对象需要在内存中存在，并且单个对象分别使用起来很不方便的时候就可以使用容器，目前比较常见的有List、Set、Map，使用方法与其他编程语言类似，其实换一个名称也就是数据结构，存储的内容也不仅仅是类。

九、异常

程序运行的过程中我们需要检查数据等操作的合法性，但是当我们无法验证这些内容的时候，我们就可以使用异常来保证程序的健壮性。

1、运行时异常
其实这种异常在编程的过程中都是可以避免的，并且这类异常一般都不会影响程序的编译是否通过

public static void testDivisor() {
    try {
      int i = 1/0;
      System.out.println("i = " + i);
    } catch (Exception e) {
      System.out.println("divisor can not be 0");
    }
  }


2、检查性异常
这类异常无法使用编程技巧进行规避，并且杂编写的过程中会影响代码的编译通过与否，所以这类问题就需要使用异常来规避了

import java.io.FileReader;

public class FileExceptionDemo {
  
  public static String readFile(){
    boolean bool = true;
    StringBuilder builder = new StringBuilder();
    try {
      FileReader fReader = new FileReader("文件路径");
      char[] cs = new char[10];
      while (fReader.read(cs)!=-1) {
        builder.append(cs);
        cs = new char[10];
      }
      fReader.close();
    } catch (Exception e) {
      bool = false;
      e.printStackTrace();
    } finally {
      if(bool) {
        System.out.println("read file ok!");
      }else {
        System.out.println("read file fail!");
        builder.replace(0, builder.length(), "fail");
      }
    }
    return builder.toString();
  }
  
  public static void main(String[] args) {
    System.out.println(readFile());
  }
}


3、自定义异常
我们在编写代码的过程中希望碰到某些异常时，抛出的内容能够让我们快速的调查出错的原因，这时候我们就可以自定义异常了。而自定义异常只需要对相关的异常进行继承，然后实现自己需要的功能就可以了。

public class CustomException extends Exception{

}
通过前面的内容我们可以实现基本的程序功能，但是在使用java构建一个稍大的系统时需要使用到控制台、文件、数据库、缓存等众多的其他java服务，所以我们需要使用I/O来解决这些问题。

十、I/O
1、控制台I/O
控制台其实就是控制输入输出的Console窗口，通过窗口输入数据我们能够读取到对应的数据并将其反馈输出到桌面。


2、文件I/O
前面有简单的文件操作，这里再重新实现一次。
这里读取的是一个python的requirements文件并输出文件的内容到前端。

import java.io.FileReader;

public class FileExceptionDemo {
  
  public static String readFile(){
    boolean bool = true;
    StringBuilder builder = new StringBuilder();
    try {
      FileReader fReader = new FileReader("C:\\Users\\Harry\\Desktop\\requirements.txt");
      char[] cs = new char[10];
      while (fReader.read(cs)!=-1) {
        builder.append(cs);
        cs = new char[10];
      }
      fReader.close();
    } catch (Exception e) {
      bool = false;
      e.printStackTrace();
    } finally {
      if(bool) {
        System.out.println("read file ok!");
      }else {
        System.out.println("read file fail!");
        builder.replace(0, builder.length(), "fail");
      }
    }
    return builder.toString();
  }
  
  public static void main(String[] args) {
    System.out.println(readFile());
  }
}