实习期间Java知识点整理（private、static、public、logger.info、try,catch、thread.sleep、map、trim、toString、substring）

Java中private、static、public用法

private

声明当前被修饰的变量、方法为私有的。这里的私有指的是仅仅可以被私有访问，举个例子：一个类就像是一台电脑，私用的部分就是除去电脑本身之外用户不可见的部分，譬如：你知道点击哪里可以登录QQ，但是内部到底是怎么登录的QQ你是不知道的，你知道摁哪里可以开关机，但是内部是怎么开关机的你是不知道的，等等，你在使用这个类时那些这个类的确有但是你访问是非法的方法或者变量是被声明为private的，私有不可见且不可访问的。
例子1：

class Film{
    private String name;
    private int price;

    public void show(){
        System.out.println(name+"------"+price);
    }
}
public class CsdnPrivate {
    public static void main(String[] args) {
        Film s = new Film();
        s.name="动物世界";
        s.price=35;
        s.show();
    }
}

结果：

由运行结果看到private访问受控，所以private只能在本类中进行运用操作。
正确代码如下：

class Film{
    private String name;
    private int price;

    public Film(){}

    public String getName(){
        return name;
    }

    public void setName(String name){
        this.name=name;
    }

    public int getPrice(){
        return price;
    }

    public void setPrice(int price){
        this.price=price;
    }
}
public class CsdnPrivate {
    public static void main(String[] args) {
        Film s = new Film();
        s.setName("动物世界");
        s.setPrice(35);
        System.out.println(s.getName()+"-----"+s.getPrice());
    }
}

结果：

由上述代码可以看到使用了setXXX()/getXXX()来操作private修饰的成员变量，setXXX()方法是是带参的，将变量传进来，getXXX()将赋值了的变量传出来。因此private只能在本类中进行运用。

class Film{
    private String name;
    private int price;
    static String country;

    public Film(String name,int price){
        this.name=name;
        this.price=price;
    }

    public Film(String name,int price,String country){
        this.name=name;
        this.price=price;
        this.country=country;
    }

    public void show(){
        System.out.println(name+"----"+price+"----"+country);
    }
}
public class CsdnPrivate {
    public static void main(String[] args) {
        Film s1 = new Film("动物世界",35,"中国");
        s1.show();

        Film s2 = new Film("心理罪",30);
        s2.show();

        Film s3 = new Film("南极之恋",25);
        s3.show();
    }
}

当用private修饰成员变量时，也可以使用带参的构造方法。上面两种方法都可以使用。

static

静态修饰符，被static修饰的变量和方法类似于全局变量和全局方法，可以在不创建对象时调用，当然也可以在创建对象之后调用。常见的可以用于工具类的工具方法中等，譬如：Math类中的绝大多数方法都是静态方法，他们扮演了工具方法的作用。
static 四种用法：
1.修饰成员变量：
在我们平时的使用当中，static最常用的功能就是修饰类的属性和方法，让他们成为类的成员属性和方法，我们通常将用static修饰的成员称为类成员或者静态成员，这句话挺起来都点奇怪，其实这是相对于对象的属性和方法来说的。请看下面的例子：（未避免程序太过臃肿，暂时不管访问控制）

public class Person {
    String name;
    int age;
    
    public String toString() {
        return "Name:" + name + ", Age:" + age;
    }
    
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.name = "zhangsan";
        p1.age = 10;
        Person p2 = new Person();
        p2.name = "lisi";
        p2.age = 12;
        System.out.println(p1);
        System.out.println(p2);
    }
    /**Output
     * Name:zhangsan, Age:10
     * Name:lisi, Age:12
     *///~
}

根据Person构造出的每一个对象都是独立存在的，保存有自己独立的成员变量，相互不会影响，我们发现，给age属性加了static关键字之后，Person对象就不再拥有age属性了，age属性会统一交给Person类去管理，即多个Person对象只会对应一个age属性，一个对象如果对age属性做了改变，其他的对象都会受到影响。我们看到此时的age和toString()方法一样，都是交由类去管理。

虽然我们看到static可以让对象共享属性，但是实际中我们很少这么用，也不推荐这么使用。因为这样会让该属性变得难以控制，因为它在任何地方都有可能被改变。如果我们想共享属性，一般我们会采用其他的办法：

public class Person {
    private static int count = 0;
    int id;
    String name;
    int age;
    
    public Person() {
        id = ++count;
    }
    
    public String toString() {
        return "Id:" + id + ", Name:" + name + ", Age:" + age;
    }
    
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.name = "zhangsan";
        p1.age = 10;
        Person p2 = new Person();
        p2.name = "lisi";
        p2.age = 12;
        System.out.println(p1);
        System.out.println(p2);
    }
    /**Output
     * Id:1, Name:zhangsan, Age:10
     * Id:2, Name:lisi, Age:12
     *///~
}

上面的代码起到了给Person的对象创建一个唯一id以及记录总数的作用，其中count由static修饰，是Person类的成员属性，每次创建一个Person对象，就会使该属性自加1然后赋给对象的id属性，这样，count属性记录了创建Person对象的总数，由于count使用了private修饰，所以从类外面无法随意改变。

2.修饰成员方法
static的另一个作用，就是修饰成员方法。相比于修饰成员属性，修饰成员方法对于数据的存储上面并没有多大的变化，因为我们从上面可以看出，方法本来就是存放在类的定义当中的。static修饰成员方法最大的作用，就是可以使用"类名.方法名"的方式操作方法，避免了先要new出对象的繁琐和资源消耗，我们可能会经常在帮助类中看到它的使用：

public class PrintHelper {

    public static void print(Object o){
        System.out.println(o);
    }
    
    public static void main(String[] args) {
        PrintHelper.print("Hello world");
    }
}

上面便是一个例子（现在还不太实用），但是我们可以看到它的作用，使得static修饰的方法成为类的方法，使用时通过“类名.方法名”的方式就可以方便的使用了，相当于定义了一个全局的函数（只要导入该类所在的包即可）。不过它也有使用的局限，一个static修饰的类中，不能使用非static修饰的成员变量和方法，这很好理解，因为static修饰的方法是属于类的，如果去直接使用对象的成员变量，它会不知所措（不知该使用哪一个对象的属性）。

3.静态块
在说明static关键字的第三个用法时，我们有必要重新梳理一下一个对象的初始化过程。以下面的代码为例：

package com.dotgua.study;

class Book{
    public Book(String msg) {
        System.out.println(msg);
    }
}

public class Person {

    Book book1 = new Book("book1成员变量初始化");
    static Book book2 = new Book("static成员book2成员变量初始化");
    
    public Person(String msg) {
        System.out.println(msg);
    }
    
    Book book3 = new Book("book3成员变量初始化");
    static Book book4 = new Book("static成员book4成员变量初始化");
    
    public static void main(String[] args) {
        Person p1 = new Person("p1初始化");
    }
    /**Output
     * static成员book2成员变量初始化
     * static成员book4成员变量初始化
     * book1成员变量初始化
     * book3成员变量初始化
     * p1初始化
     *///~
}

上面的例子中，Person类中组合了四个Book成员变量，两个是普通成员，两个是static修饰的类成员。我们可以看到，当我们new一个Person对象时，static修饰的成员变量首先被初始化，随后是普通成员，最后调用Person类的构造方法完成初始化。也就是说，在创建对象时，static修饰的成员会首先被初始化，而且我们还可以看到，如果有多个static修饰的成员，那么会按照他们的先后位置进行初始化。

4.静态导包
相比于上面的三种用途，第四种用途可能了解的人就比较少了，但是实际上它很简单，而且在调用类方法时会更方便。以上面的“PrintHelper”的例子为例，做一下稍微的变化，即可使用静态导包带给我们的方便：

/* App.java文件 */

import static com.dotgua.study.PrintHelper.*;

public class App 
{
    public static void main( String[] args )
    {
        print("Hello World!");
    }
    /**Output
     * Hello World!
     *///~
}

/* PrintHelper.java文件 */
package com.dotgua.study;

public class PrintHelper {

    public static void print(Object o){
        System.out.println(o);
    }
}

上面的代码来自于两个java文件，其中的PrintHelper很简单，包含了一个用于打印的static方法。而在App.java文件中，我们首先将PrintHelper类导入，这里在导入时，我们使用了static关键字，而且在引入类的最后还加上了“.*”，它的作用就是将PrintHelper类中的所有类方法直接导入。不同于非static导入，采用static导入包后，在不与当前类的方法名冲突的情况下，无需使用“类名.方法名”的方法去调用类方法了，直接可以采用"方法名"去调用类方法，就好像是该类自己的方法一样使用即可。

总结
static是java中非常重要的一个关键字，而且它的用法也很丰富，主要有四种用法：
用来修饰成员变量，将其变为类的成员，从而实现所有对象对于该成员的共享；
用来修饰成员方法，将其变为类方法，可以直接使用“类名.方法名”的方式调用，常用于工具类；
静态块用法，将多个类成员放在一起初始化，使得程序更加规整，其中理解对象的初始化过程非常关键；
静态导包用法，将类的方法直接导入到当前类中，从而直接使用“方法名”即可调用类方法，更加方便。
原文：https://blog.csdn.net/shuyizhi/article/details/79700054

public

声明当前被修饰的对象、方法、变量为公有的。这里的公有指的是可以被公有访问，举个例子：一个类就像是一台电脑，公有的部分就是除去电脑本身之外用户可见的部分，譬如:你知道点击哪里可以登录QQ，摁哪里可以开关机，等等，你可以使用这个类所有的可见的东西都是被声明为public的，公有可见且公有可被访问的。
所以，被private static修饰的属性仅仅可以被静态方法调用，但是只能被本类中的方法（可以是非静态的）调用，在外部创建这个类的对象或者直接使用这个类访问都是非法的。
被public static修饰的属性除了可以被静态方法和非静态调用之外，还可以直接被类名和外部创建的对象调用。
综上呢，private static是合法的，且有着其独到的用处：为静态方法提供私有静态属性。public static常用的是为该类提供对外暴露即可以被类名直接调用的静态常量。

原文：https://blog.csdn.net/weixin_41666244/article/details/81175511
原文：https://blog.csdn.net/Wenco1/article/details/89923315

Java中logger。info

简单的说，就是配合log的等级过滤输出。
比如，你在开发的时候，要验证一个方法有没有被调用到，为了方便调试，通常会在这个方法开始的时候加一些system.out。但是项目真正发布的时候这些代码通常是要移除掉的，所以通常更建议用logger来记录。
所以你可能会加logger.debug。 为什么是debug而不是info error或者其他呢？因为通常项目发布的时候都会把日志等级设置为error 或者info之类的等级，在这两个等级下debug的内容是输出不了的，所以就可以做到不需要修改代码就不会输出你只有在调试的时候才需要输出的内容。
各个等级都是有它的含义的，虽然在代码写的时候你用debug info error都是可以，但是为了方便管理，只有调试的时候才用到日志会用debug，一些信息类的日志记录通常会用info（比如你想看一天有几个用户登录），一些错误的，或者异常信息会用error，比如某个时刻数据库连接出了问题，如果分析日志，直接搜索error开头的就能直接定位到了。

logger.debug,logger.info,logger.warn,logger.error,logger.fatal的作用都是把错误信息写到文本日志里，
不同的是它们表示的日志级别不同：
日志级别由高到底是：fatal,error,warn,info,debug,低级别的会输出高级别的信息，高级别的不会输出低级别的。

信息，如等级设为Error的话，warn,info,debug的信息不会输出。

修改日志输出的级别要在log4j文件中进行配置。
项目正式发布后，一般会把日志级别设置为fatal或者error。

原文：https://blog.csdn.net/fengxuezhiye/article/details/7367749
原文：https://blog.csdn.net/wzq__janeGreen_/article/details/80695866

Java中try,catch用法

try{
    //代码区
    }catch(Exception e){
    //异常处理
    e.printStackTrace();
    }

代码区如果有错误，就会返回所写异常的处理。
当try语句中出现异常是时，会执行catch中的语句，java运行时系统会自动将catch括号中的Exception e 初始化，也就是实例化Exception类型的对象。e是此对象异常名称。然后e（引用）会自动调用Exception类中指定的方法，也就出现了e.printStackTrace();。printStackTrace()方法的意思是：在命令行打印异常信息在程序中出错的位置及原因。

Java中thread.sleep

Thread.sleep(long millis)和Thread.sleep(long millis, int nanos)静态方法强制当前正在执行的线程休眠（暂停执行），以“减慢线程”。
当线程睡眠时，它睡在某个地方，在苏醒之前不会返回到可运行状态。
当睡眠时间到期，则返回到可运行状态。
https://blog.csdn.net/yujie_success/article/details/71157588

Java中map

map是Java中提供的一种通用的元素存储方式，用于保存具有映射关系的数据，它是一种集合类。map集合类用于存储键值对（“键”、“值”）即Map<key,value>，每个键映射到一个值。但要注意的是key不能重复。所以通过指定的key就可以取出对应的value。

Map的三个特点
1.包含键值对
2.键唯一
3.键对应的值唯一
map储存数据的形式是一个key和一个value对应，即

Map<String,String> map = new HashMap<String,String>(); 

其储存的数据类型可以是任意的。
接下来我们简单的介绍一下它添加数据和遍历数据的方法：

 map.put("key1", "value1");
    map.put("key2", "value2");
    map.put("key3", "value3");
      
   //第一种：普遍使用，二次取值

 System.out.println("通过Map.keySet遍历key和value：");

for (String key : map.keySet()) {  //通过foreach方法来遍历

System.out.println("key= "+ key + " and value= " + map.get(key));
      }
      
//第二种
  System.out.println("通过Map.entrySet使用iterator遍历key和value：");

 Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();  //通过构造操作符来遍历
 while (it.hasNext()) {

Map.Entry<String, String> entry = it.next();

  System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
      }
      
//第三种：推荐，尤其是容量大时
System.out.println("通过Map.entrySet遍历key和value");  //同样是foreach方法

 for (Map.Entry<String, String> entry : map.entrySet()) {

System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
      }
    
//第四种
  System.out.println("通过Map.values()遍历所有的value，但不能遍历key");

for (String v : map.values()) {

System.out.println("value= " + v);
 }
 }

https://blog.csdn.net/qq_36719861/article/details/79503456

常用方法
https://www.cnblogs.com/xiaostudy/p/9510763.html

Java中trim()

trim()目的是去除空格，返回调用字符串对象的一个副本，但是所有起始和结尾的空格都被删除了，例子如下：String s=" Hello World ".trim();就是把"Hello World"放入s中。

Java中toString()

toString() 方法返回此对象本身（它已经是一个字符串）。

public String toString()

eg:

    public class Test {
        public static void main(String args[]) {
            String Str = new String("WWW.RUNOOB.COM");
    
            System.out.print("返回值 :" );
            System.out.println( Str.toString() );
        }
    }

结果：

返回值 :WWW.RUNOOB.COM

Java中substring()

substring() 方法返回字符串的子字符串。

 public String substring(int beginIndex)
  或    
  public String substring(int beginIndex, int endIndex)
  ```
  
beginIndex -- 起始索引（包括）, 索引从 0 开始。
endIndex -- 结束索引（不包括）。

```java
public class Test {
  public static void main(String args[]) {
      String Str = new String("www.runoob.com");

      System.out.print("返回值 :" );
      System.out.println(Str.substring(4) );

      System.out.print("返回值 :" );
      System.out.println(Str.substring(4, 10) );
  }
}

结果

返回值 :runoob.com
返回值 :runoob