newer20200730总结

20200716总结：

1. 访问限定符的用法

1、访问限定符的用法：
default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
public : 对所有类可见。使用对象：类、接口、变量、方法
protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。

私有访问修饰符-private
私有访问修饰符是最严格的访问级别，所以被声明为 private 的方法、变量和构造方法只能被所属类访问，并且类和接口不能声明为 private。
声明为私有访问类型的变量只能通过类中公共的 getter 方法被外部类访问。
Private 访问修饰符的使用主要用来隐藏类的实现细节和保护类的数据。

public class ClassName{
   private String format;
   public String getFormat() {
      return this.format;
   }
   public void setFormat(String format) {
      this.format = format;
   }
}

实例中，ClassName 类中的 format 变量为私有变量，所以其他类不能直接得到和设置该变量的值。为了使其他类能够操作该变量，定义了两个 public 方法：getFormat() （返回 format的值）和 setFormat(String)（设置 format 的值）

公有访问修饰符-public:
被声明为 public 的类、方法、构造方法和接口能够被任何其他类访问。
如果几个相互访问的 public 类分布在不同的包中，则需要导入相应 public 类所在的包。由于类的继承性，类所有的公有方法和变量都能被其子类继承。

public static void main(String[] arguments) {
   // ...
}

Java 程序的 main() 方法必须设置成公有的，否则，Java 解释器将不能运行该类。

受保护的访问修饰符-protected
protected 需要从以下两个点来分析说明：
子类与基类在同一包中：被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问；
子类与基类不在同一包中：那么在子类中，子类实例可以访问其从基类继承而来的 protected 方法，而不能访问基类实例的protected方法。
protected 可以修饰数据成员，构造方法，方法成员，不能修饰类（内部类除外）。
接口及接口的成员变量和成员方法不能声明为 protected。 可以看看下图演示：

子类能访问 protected 修饰符声明的方法和变量，这样就能保护不相关的类使用这些方法和变量。
下面的父类使用了 protected 访问修饰符，子类重写了父类的 openSpeaker() 方法。`

class AudioPlayer {
   protected boolean openSpeaker(Speaker sp) {
      // 实现细节
   }
}
 
class StreamingAudioPlayer extends AudioPlayer {
   protected boolean openSpeaker(Speaker sp) {
      // 实现细节
   }
}

如果把 openSpeaker() 方法声明为 private，那么除了 AudioPlayer 之外的类将不能访问该方法。
如果把 openSpeaker() 声明为 public，那么所有的类都能够访问该方法。
如果我们只想让该方法对其所在类的子类可见，则将该方法声明为 protected。
protected 是最难理解的一种 Java 类成员访问权限修饰词，更多详细内容请搜索 Java protected 关键字详解。

访问控制和继承
请注意以下方法继承的规则
父类中声明为 public 的方法在子类中也必须为 public。
父类中声明为 protected 的方法在子类中要么声明为 protected，要么声明为 public，不能声明为 private。
父类中声明为 private 的方法，不能够被继承。

2. this和super的用法？

this
1、用在一个方法中，表示调用当前方法的对象，代表当前类的一个对象，可 以调用本类的方法
2、用在构造方法中，表示调用当前类的另外一个构造方法，具体用哪一个， 取决于参数列表（只能放在第一行，且只能调用一个）
3、区分实例变量和局部变量

//	father类的无参构造
public Father(){
	this("wl",21);   //this()，只能放在第一行，无参构造调用了
//	this(null,0);
	System.out.println("father类的无参构造");
	}
//	father类的有参构造
public Father(String name,int age){
	System.out.println("father类的有参构造");
    this.setAge(age);
	this.name=name;
}
Main中：
Father f=new Father();    //调用了无参构造
System.out.println(f.getName()+"  "+f.getAge());
output：father类的无参构造

运行结果：wl  21

super
super代表了父类的引用。
可以有三种用法：
1.super可以直接调用父类的方法
2.super可以直接调用父类的变量
3.super()那么相当于调用父类的构造函数

3. final的用法？

1、用来修饰数据，包括成员变量和局部变量，该变量只能被赋值一次且它的值无法被改变。对于成员变量来讲，我们必须在声明时或者构造方法中对它赋值；
2、 用来修饰方法参数，表示在变量的生存期中它的值不能被改变；
3、 修饰方法，表示该方法无法被重写；
4、修饰类，表示该类无法被继承。

4. static的用法？

static  静态的
可以用来声明类，属性，方法和代码块
static属性:类属性    该类所有的对象共享的一个变量
非静态属性：成员属性  该类的每一个对象都独立的有一个变量

static方法：类方法
非static方法：成员方法
调用成员方法的时候，根对象本身的类型[new的类型]有关系
在调用类方法的时候，只跟变量的类型有关系

static属性和static方法可以通过对象来调用      
      但通常情况下都直接通过类名调用
在静态方法中不能够直接调用非静态的属性和方法

static类：一般用来定义内部类[嵌套类]

static代码块
static{
}

5. String的类的常用构造方法和常用方法？

字符串的构造方式
String s = "ABCD";
String s = new String("ABCD");

 //字符数组转换成字符串
String s = new String(char[]);
String s = new String(char[],startIndex,count);

//字节数组转换成字符串
String s = new String(byte[]);
String s = new String(byte[],charset);
String s = new String(byte[],startIndex,count,charset);

字符串的常用方法
字符串转换成字符数组
   toCharArray();
字符串转换成字节数组
    getBytes();
    getBytes(charset);
    
查找
    charAt(index);  根据下标取出一个字符
    indexOf(s);     查找s在字符串中第一次出现的下标位置
    lastIndesOf(s); 查找s在字符串中最后一次出现的下标位置
    contains(s);    是否包含指定的字符串

匹配
    equals(s)  字符串是否以指定的字符串"相等"
    equalsIgnoreCase(s)字符串是否以指定的字符串"相等" 忽略大小写
    match(s)    字符串是否以指定的字符串匹配

替换
    replace(oldString,newString)    替换指定的字符串
    replaceAll(oldString,newString)替换指定的字符串
    replaceFirst(oldString,newString) 替换指定的字符串,只替换第一次出现的

截取
    subString(start)
    subString(start,end);


切割
    split("标记") 
    
字符串长度:包含多少个字符
    length()
    
    String StringBuilder  StringBuffer
    String 基于char数组[jdk8]的实现，一旦定义好，长度就不可改变
    基于byte数组[jdk11]的实现

    当进行字符串拼接的时候，每次都需要创建新的数组，来存放数据


    String类为final类型的，不可继承，存储的是字符串常量，是不可改变的。
（每次赋值都是重新创建一个对象）

而StringBuffer类存储的是字符串变量，可以对字符串进行一系列的操作。

比如String str = “abc”,str = str + “de” ,   
输出的虽然是abcde，但是实际情况是，我们先创建一个String对象str，
并把“abc”赋值给str，然后str = str+”de”执行的是，
JVM创建了一个新的对象也名为str，然后再把原来的str的值和“de”加起来再
赋值给新的str，
而原来的str就会被JVM的垃圾回收机制（GC）给回收掉了。

StringBuffer类是线程安全的，适合多线程在字符缓冲区进行操作的情况。

StringBuilder与StringBuffer 长度可变字符串 
StringBuilder的性能要高于StringBuffer
StringBuilder是线程不安全的
StringBuffer是线程安全的

由于StringBuffer需要进行线程的同步操作，其性能要比StringBuilder差
StringBuffer适用于多线程的并发操作。

Java20200730总结

1、面向对象编程

面向对象详细链接

2、数组[ArrayList Stack Vector]

3、链表[LinkedList LinkedBlockingQueue]

4、映射[HashMap TreeMap]

5、文件操作

6、I\O