1. 类中全部成员变量用priviate修饰，用get获取，set设值

对于boolean类型的值，getter方法也一定要写成isXXX 的形式，而setXXX类型不变

2. this关键字的作用
   当方法的局部变量和类的成员变量重名的时候，根据“就近原则”，优先使用局部变量。如果要访问本类当中的成员变量，需要使用格式：
   this.成员变量名
   通过谁调用的方法，this就是谁
3. 构造方法：
   当我们用关键字new来创建对象时，其实就是在调用构造方法

public 类名称(参数类型 参数名称){
    方法体
}
//与类名完全一样
//构造方法不要写返回值 
//一旦编写了至少一个构造方法，那么编译器将不再赠送默认构造方法

4. 重载函数名相同，返回值相同，参数列表不同
5. 一个标准的类通常要拥有下面四个组成部分
   • 所有成员变量都要使用private修饰
   • 为每个成员变量编写一对Getter/Setter方法
   • 编写一个无参数的构造方法
   • 编写一个全参数的构造方法

这样标准的类也叫做Java Bean

6. Idea中快捷编写getter/setter可以有点击上方的菜单栏中的 Code-Generate选择Getter and Setter

编写constructor同理

7. Scanner类

• 实现键盘输入数据到程序当中

引用类型的一般使用步骤
1.导包
import  包路径.类名称
如果需要使用的目标类和当前类位于同一个包下，则可以省略导包语句不写
只有java.lang包下的内容不需要导包，其他的包都需要import语句

2. 创建
类名称 对象名 = new 类名称()

3. 使用
对象.成员方法名()

//System。in代表从键盘进行输入
//获取键盘输入的int数字：int num = sc.nextInt();
//获取键盘输入的一个字符串：String str = sc.next()
Scanner sc = new Scanner(System.in)
int num = sc.nextInt();
//Idea中绿色代表键盘输入

8. 匿名对象

只有右边的对象，没有左边的名字和赋值运算符

new 类名称

可作为方法的参数

9. Random类

import java.util.Random
//获取一个随机的Int数字（范围是Int所有范围，有正负两种）
Random r = new Random()
//范围是参数，左开右闭[0，3）
Random r2=new Random(3)
int num = r.nextInt()

10. 对象数组
11. ArrayList

泛型，只能是引用类型，不能是基本类型

ArrayList<String> list = new ArrayList()

从JDK1.7开始，右侧的尖括号内不可以不写内容，但<>还是要写的

add()       //ArrayList添加一定会成功
get()       //从集合中获取元素，索引从0开始
isEmpty()
remove()
size()

如果希望向集合ArrayList当中存储基本类型的数据，必须使用基本类型对应的包装类

从jdk1.5+开始，支持自动装箱、自动拆箱

自动装箱：基本类型-->包装类型

自动拆箱：包装类型-->基本类型

12.字符串String

""都是String类对象

字符串的特点：

• 字符串的内容永不可变
• 正是因为字符串不可改变，所以字符串是可以共享使用的
• 字符串效果上相当于char[]字符数组，但是底层原理是byte[]字节数组

字符串创建3+1方式

• public String():创建一个空白字符串，不含有任何内容
• public String(char[] array):根据字符数组的内容来创建对应的字符串
• public String(byte[] array):根据字节数组的内容来创建对应的
• 直接创建

字符串的常量池

程序中直接写上双引号字符串，就在字符串常量池中

字符串常量池中的对象，保存的是byte[]的地址值

new了就不在常量池了

对于基本类型来说，==是进行数值的比较

对于引用类型来说，==是进行【地址值】的比较

String str1 = "abc";
String str2 = "abc";

char[] charArray={'a','b','c'};
String str3 = new String(charArray);

System.out.println(str1==str2)//true
System.out.println(str1==str3)//false
System.out.println(str3==str3)//false

字符串的比较

//==是进行对象的地址值比较
//如果需要字符串的内容比较，可以使用两个方法：
/*
参数可以是任何对象，只有参数是一个字符串并且内容相同的才会给true；否则返回false
注意：
1.任何对象都能用Object进行接收
2.equals方法具有对称性
3.如果比较双方一个常量一个变量，推荐把常量字符串写在前面
*/
public boolean equals(Object obj):

字符串的获取

public int Length()             //获取字符串当中含有的字符个数，拿到字符串长度
public String concat(String str)//将当前字符串和参数字符串拼接成为返回值新的字符串
public char charAt(int index)   //获取指定索引位置的单个字符
public int indexOf(String str)  //查找参数字符串在本字符当中首次出现的索引位置，如果没有返回-1

字符串的截取

public String substring(int index)//截取从参数为止质疑道字符串末尾,返回新字符串
public String substring(int begin, int end)//获取[begin,end)区间的新的字符串

字符串的转换相关方法

public char[] toCharArray()//将当前字符串拆分成为字符数组作为返回值
public byte[] getBytes()//获得当前字符串底层的字节数组
//将所有出现的老字符串替换成为新的字符串,返回替换之后的结果新字符串
public String replace(CharSequence oldString,CharSequence newString)//CharSequence意思是说可以接受字符串类型

分割字符串的方法

public String[] split(String regex)//按照参数的规则，将字符串切分成为若干部分

注意事项
regex是正则表达式，英文的 “.” 不能直接用,使用“//.”写两个反斜杠

13. static 静态关键字

只在类当中保存唯一一份，所有本类对象共享一份，这样的内容属于类

可以修饰变量和方法

对静态方法来说，可以通过对象名进行调用，也可以直接通过类名称调用（推荐）

静态方法可以访问静态变量，但不能访问非静态变量

静态方法中不能用this

静态代码块

典型用途：
用来一次性的对静态成员变量赋值

public class 类名称{
    static {
        //静态代码块
    }
    //当第一次用到本类时，静态代码块执行唯一一次
    //静态内容总是优先于非静态
    }
}

14. Arrays：是一个与数组相关的工具类，里面提供了大量静态方法，用来实现数组常见的操作

public static String toString(数组)//将参数数组变成字符串(按照默认格式[元素1，元素2，...])
public static void sort(数组)//按照默认从小到大对数组元素进行排序
备注：
1. 如果是数值和字符串默认升序
2. 如果是自定义的类型，那么这个自定义的类需要有Comparable或者Comparator接口的支持

15. Math类

public static double abs(doube num)         //获取绝对值
public static double ceil(double num)       //向上取整
public static double floor(double num)      //向下取整
public static long round(double num)        //四舍五入

Math.PI//近似的圆周率
Math.max()
Math.min()

16. 继承性

主要解决的问题就是==共性抽取==

父类，也可以叫基类，超类
子类，也可以叫派生类

格式

//继承关系中，子类就是一个父类，可以被当做父类看待
public class 子类名称 extend 父类名称{
    //会直接继承来自父类的方法
}

子类父类成员变量重名，则创建子类对象时，访问有两种方式

• 直接通过子类对象访问成员变量。等号左边是谁，优先访问谁，没有则向上找
• 间接通过成员方法访问成员变量。该方法属于谁，优先用谁，没有则向上找

局部变量：直接写

本类的成员变量：this.成员变量名

父类的成员变量：super.成员变量名

重写(Override)：方法的名称一样，参数列表【也一样】（覆盖，覆写）

重载(Overload)：方法的名称一样，参数列表【不一样】

//@Override 写在方法前面，用来检测是不是有效的正确覆盖重写
@Override
public 返回值 method(){
    //子类方法的返回值必须小于等于父类方法的返回值类型
    //也就是说子类方法的返回值可以和父类方法不同
    //子类方法的权限必须【大于等于】父类方法的权限修饰符
    //public > protected (default) > private
    super.method()
}

继承关系中，父子类构造方法的访问特点：

1. 子类构造方法当中有一个默认隐含的super()调用，所以一定是先调用父类构造，后执行子类构造
2. 可以通过super(参数列表)关键字调用父类重载的构造方法
3. super的父类构造调用，必须是子类构造方法的第一个语句，不能一个子类构造调用多次super构造

super关键字的三种用法

1. 在子类的成员方法中访问父类的成员变量
2. 在子类的成员方法中，访问父类的成员方法
3. 在子类的构造方法中访问父类的构造方法

this关键字的三种用法

1. 在本类的成员方法中访问本类的成员变量
2. 在本类的成员方法中访问本类的另一个成员方法
3. 在本类的构造方法中访问本类的另一个构造方法

A. this(...)调必须是构造方法的第一个语句，唯一一个

B. super和this两中构造调用不能同时使用

==Java语言是单继承的==

一个类的直接父类只能有唯一一个

==Java语言可以多级继承==

17. 抽象

抽象方法：就是加上 ==abstract==关键字，然后去掉大括号，直接分好结束

抽象类： 抽象方法所在的类，必须是抽象类才行。在class前写上abstract即可

使用抽象类和抽象方法

1. 不能直接创建new抽象类对象
2. 必须用一个子类来继承抽象父类
3. 子类必须覆盖重写抽象父类当中所有的抽象方法

子类去掉抽象方法中的abstract关键字，然后补上方法体大括号

4. 创建子类对象使用

18. 接口

接口是一种公共的规范标准

//接口就是多个类的公共规范
//接口是一种引用数据类型，最重要的内容就是其中的：抽象方法

public interface 接口名称{
    //接口内容
}

//备注：换成了关键字interface之后编译生成的字节码文件仍然是：.java---> .class。

如果是java7,那么接口中可以包含的内容有：
1. 常量
2.抽象方法

如果是java8,还可以额外包含有
3.默认方法
4.静态方法

如果是java9,还可以额外包含有
5.私有方法

接口中的==抽象方法==，修饰符必须是两个固定的关键字:public abstract

这两个关键字修饰符，可以选择性地省略，可以省略全部也可以省略一部分

接口使用步骤：
1. 接口不能直接使用，必须有一个实现类来实现接口

public class 实现类名称 implements 接口名称{
    // ...
}
2.接口的实现类必须覆盖重写（实现）接口中所有的抽象方法。
3.创建实现类的对象进行使用 
//不能直接new接口对象使用

如果实现类并没有覆盖重写接口中所有的抽象方法，那么这个实现类自己就必须是抽象类。

接口中的==默认方法==

public default 返回值类型 方法名称(参数列表){
    
}
是为了实现接口升级设计的
1.接口的默认方法，可以通过接口实现类对象直接调用
2.接口的默认方法，也可以被接口实现类覆盖重写

接口中的==静态方法==

jdk8开始，接口当中允许定义静态方法

//就是将 abstract 或者 default 换成 static 就行了
public static 返回值类型 方法名称(参数列表){
    
}

不能通过接口实现类的对象来调用接口当中的静态方法
==通过接口名称，直接调用其中的静态方法==

问题描述

我们需要抽取一个公有方法，用来解决两个默认方法之间重复代码的问题。

但是这个 公有方法不应该让实现类实现，应该是私有化的

解决方案：

从jkd9开始，接口当中允许定义私有方法

1. 普通私有方法，解决多个默认方法之间重复的代码问题
private 返回值类型 方法名称(参数列表){
    //
}

2.静态私有方法解决多个静态方法之间重复代码问题
private static 返回值类型 方法名称(){
    //
}

接口当中也可以定义成员变量，但是必须使用==public static final==关键字修饰

从效果上看，这其实就是接口的常量

public static final 数据类型 常量名称 = 数据值
//一旦赋值不可以修改
//可以省略 public static final
//接口中的常量必须进行赋值
//接口中常量的名称，用大写字母，用下划线进行分隔

注意事项：
1. 接口中不能有静态代码块
2. 接口中不能有构造方法
一个类只能有一个父类，但接口可以有多个
public calss MyInterfaceImpl implements MyInterefaceA,MyInterfaceB{
    //覆盖重写所有抽象方法
}
3. 如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次
4. 如果实现了利没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类
5. 如果实现类所实现的多个接口当中，存在重复的默认方法，那么实现类必须对冲突的默认方法覆盖重写
6. 一个类如果直接父类当中的方法和接口当中的方法产生冲突，优先使用父类的方法

类与类之间是单继承的，直接父类只有一个

类与接口之间是多实现的，一个类可以实现多个接口

接口与接口之间是多继承的

注意事项

1，多个父接口当中的抽象方法如果重复，没关系

2, 多个父接口当中的默认方法如果重复，重写该默认方法，带着default关键字

18. 多态

==extends==继承或者==implements==实现是多态性的前提

代码当中体现多态性，其实就是一句话，父类引用指向子类对象

父类名称 对象名 = new 子类对象()
或者
接口名称 对象名 = new 实现类名称()

左父右子就是多态，左侧父类对象当做子类对象使用

但成员变量还是父类的，左边是谁，优先访问谁

访问成员变量

1. 直接通过对象名称访问成员变量，看等号左边是谁优先访问谁，没有则向上找
2. 间接通过成员方法访问成员变量，看该方法属于谁，优先用谁，没有则向上找

访问成员方法：
看new的是谁，就优先用谁，没有则向上找

口诀：==编译看左边，运行看右边==，成员变量是 编译看左边运行看左边

19. 对象的向上转型

1. 对象的向上转型，其实就是多态写法

格式：父类名称 对象名 = new 子类名();

含义：右侧创建一个子类对象，把它当做父类来看待使用

==向上转型一定是安全的==从小范围转向了大范围

对象一旦向上转型为父类，那么久无法调用子类原本特有的内容

2. 对象的向下转型，其实是一个【还原】的动作

格式：子类名称 对象名 = (子类名称)父类对象;

含义：将父类对象，【还原】为本来的子类对象

如何才能知道一个父类引用的对象本来是什么子类？

对象 instanceof 类名称

这将会得到一个boolean值结果，也就是判断前面的对象能不能当做后面类型的实例

//判断父类引用animal本来是不是Dog
if(animal instanceof Dog){
    Dog dog = (Dog)animal
}

20. final关键字

四种用法
1.可以用来修饰一个类
2.可以用来修饰一个方法
3.还可以用来修饰一个局部变量
4.还可以用来修饰一个成员变量

public final class 类名称{
    //当前这个类不能有任何的子类（太监类）
    
    //当final 关键字用来修饰一个方法的时候，这个方法就是最终方法，也就是不能被覆盖重写
    
    //一旦使用final来修饰局部变量，那么这个变量就不能进行更改
    //引用类型地址值不能变，内容可以变
    
    //对于成员变量来说，如果使用final，那么这个变量也照样不变
    //要手动赋值
}

==abstract 和 final 不能同时使用==

21.四个权限修饰符

22.内部类

分类

1. 成员内部类
2. 局部内部类（包含匿名内部类）

修饰符 class 外部类名称{
    修饰符 class 内部类名称{
        
    }
}
注意： 内用外，随意访问；外用内，需要内部类对象

直接方式：
外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();
如果出现重名现象;
外部类名称.this.内部重名 

局部内部类
修饰符 class 外部类名称{
    修饰符 返回值类型 外部类方法名称(参数列表){
        class 局部内部类名称{
            
        }
    }
}

定义一个类的时候，权限修饰符规则：

1. 外部类：public /(default)
2. 成员内部类：public / protected / (default) / private
3. 局部内部类：什么都不能写

局部内部类，如果希望访问所在方法的局部变量，那么这个局部变量必须是【有效final的】
备注：从java 8+开始i，只要局部变量事实不变，那么final关键字可以省略

原因：

1. new出来的对象在堆内存当中。
2. 局部变量是跟着方法走得，在栈内存当中
3. 方法运行结束之后，立刻出站，局部变量就会立即消失
4. 但是new出来的对象会在堆当中持续存在，知道垃圾回收消失

23.匿名内部类

如果接口的实现类，或者是父类的子类，只需要使用唯一的一次
那么这种情况下就可以省略掉该类的定义而改为使用==匿名内部类==

格式：

接口名称 对象名 = new 接口名称{
    //覆盖重写所有抽象方法
}

24. Object类

toString方法:

1. 直接打印对象的名字其实就是调用对象的toString方法
2. 重写后直接打印这个对象名字，也是调用toString方法

equals方法

1. 基本数据类型，比较的是值
2. 引用数据类型，比较的是两个对象的地址值

Object类的equals方法，默认比较的是两个对象的地址值，没有意义
问题：

隐含着一个多态，多态的弊端：无法使用子类特有的内容（属性和方法）

解决：可以使用向下转型（强转）转换为子类

object类equals方法：对两个对象进行比较，防止空指针异常

public static boolean equals(Object a,Object b){
    return (a==b)||(a!=null && a.equals(b));
}

25. Data类

表示特定的瞬间，精确到毫秒

使用DatFormat类中的方法format,吧日期格式转化为文本

使用步骤：

1. 创建SimpleDataFormat对象，构造方法中传递指定的模式
2. 调用SimpleDataFormat对象中的方法format，按照构造方法中指定的模式，把Data日期格式化为符合模式的字符串（文本）
   3

SimpleDataFormat sdf = new SimpleDataFormat("yyyy年MM月dd入 HH时mm分ss秒");
Date date = new Date()
String format = sdf.format(date)

26. Calendar类

Calendar类是一个抽象类，里面提供了很多操作日历字段的方法(YEAR,MONTH,DAY_OF,HOUR)

Calendar类无法直接创建对象使用，里边有一个静态方法叫getInstance()，该方法返回了Calendar类的子类对象

static Calendar getInstance()使用默认时区和语言环境获得一个日历

27. System类

public static long currentTimeMillis():返回以毫秒为单位的当前时间

public static void arraycopy(Object src, int srcPos,Object dest, int destPos, int length):将数组中指定的数据拷贝到另一个数组中

28. StringBuilder类

String类：

字符串是常量；它们的值在被创建后不能更改，字符串的底层是一个被final修饰的数组，是一个常量

private final byte[] value

进行字符串的相加，内存中就会有多个字符串，占用空间多，效率低下

StringBuilder类：

字符串缓冲区，可以提高字符串的操作效率，可以看成一个长度可以变化的字符串

底层也是一个数组，但是没有被final修饰，可以改变长度

byte[] value = new byte[16]

==StringBuilder在内存中始终是一个数组==，占用空间少，效率高

如果超出了容量，会自动扩容

有空参和带字符串的构造方法

两个常用成员方法：append()和toString()

StringBuilder bu = new StringBuilder();
//append()方法返回的是this，调用方法的对象bu，this==bu，无需接受返回值
StringBuilder bu2 = bu.append("abc")
sout(bu)    //"abc"
sout(bu2)   //"abc"
sout(bu==bu2)//比较的是地址值true 

29.包装类

基本数据类型，使用起来非常方便，但没有对应的方法来操作这些基本类型的数据，可以使用一个类，把基本类型的数据封装起来，在类中定义一些方法，这个类叫做包装类

30. 装箱与拆箱

装箱：
把基本类型的数据包装到包装类中

拆箱：
在包装类中取出基本类型的数据

自动装箱和自动拆箱：基本类型的数据和包装类之间可以自动的转换

31. 基本类型与字符串之间的相互转换

基本类型->字符串（String）

1.基本类型的值+""最简单的方法（工作中常用）
2.包装类的静态方法toString(参数)，不是Object类的toString()重载
    static String toString(int i)// 返回一个表示指定整数的String对象
3.String类的静态方法valueOf(参数)
    static String valueOf(int i) // 返回int参数的字符串表示形式

字符串（String）-> 基本类型

使用包装类的静态方法parseXXX("字符串")
Integer类： static int parseInt(String s)
Double类：static double parseDouble(String s)