一、String类
在JAVA中，String字符串用双引号引起来，字符串严格来说就是字符的数组集合：
在JDK1.8及以前，String类使用char []字符数组保存字符串，而1.9及以上使用byte []字节数组保存字符串。
1、字符串的比较：
字符串如果用 "==" 进行比较，比较的是两个对象的内存地址是否相同，用equals()才是比较内容是否相同：
public class Test{
public static void main(String args[]) {
String s1 = "hello";
String s2 = new String("hello");
System.out.println(s1 == s2); //false
System.out.println(s1.equals(s2));//true
}
}String类常用方法：
int->String.length()：返回字符串的长度
boolean->String.isEmpty()：判断字符串是否为空或者长度为0
char->String.charAt()：返回char指定索引的值
boolean->String.equals()：字符串比较
int->String.indexOf()：返回指定字符第一次出现的索引位置
String->String.substring()：返回截取的子字符串
String->String.replace()：字符串替换：一个
String->String.replaceAll()：字符串替换:全部
String []->String.split()：字符串分割
String->String.join()：字符串组合
String->String.trim()：删除首尾空格
二、继承性
定义：class 子类 extends 父类 {}
子类也叫派生类，父类也叫超类。继承实现的主要目的是在于子类可以重用父类中的结构，并且实现功能的扩充，描述的范围更小。
class A {
public void getinfo() {
System.out.print("子类继承父类结构");
}
}
class B extends A {} //B子类继承父类A
public class Test {
public static void main(String[] args) {
B b1 = new B();
b1.getinfo();//得到父类的方法
}
}super()方法：
表示子类构造调用父类构造的语句，该方法只允许放在子类构造方法首行，默认调用的是父类的无参构造方法。所以不允许super()和super(参数)同时出现。
class A {
private String name;
private int age;
public A() {
System.out.println("子类实例化会首先实例化父类构造方法");
}
public A(String name,int age) {
this.name = name;
this.age = age;
}
public void getinfo() {
System.out.print("姓名：" + this.name + " 年龄：" + this.age);
}
}
class B extends A {
private String addr;
// public B() {
// super(); //子类调用父类的无参构造方法
// }
public B(String name, int age ,String addr) {
super(name,age); //子类调用父类的有参构造方法
this.addr = addr;
}
}
public class Test {
public static void main(String[] args) {
// B b1 = new B();
// b1.getinfo();
B b2 = new B("小明",20,"重庆");
b2.getinfo();
}
}
JAVA不支持多重继承（同时继承多个父类 clss C extends A,B{} ），但是可以多层继承：B继承A，C继承B，那么C就有了A和B的结构。
class A{}
class B extends A{}
class C extends b{}方法覆写：
当子类中出现的方法和父类中出现的方法相同时（方法名和参数），就叫做覆写（类似于方法的重载），那么实例化后就调用的是子类的方法，若要调用父类的方法可使用super.方法()：
class A{
public void getinfo() {
System.out.print("父类getinfo方法");
}
}
class B extends A{
public void getinfo() {
super.getinfo(); //调用父类的getinfo方法
System.out.print("子类getinfo方法");
}
}
public class Test {
public static void main(String[] args) {
B b1 = new B();
b1.getinfo(); //父类getinfo方法子类getinfo方法
}
}
若只是方法名相同，那么会根据传入的参数自动调用子类或父类的方法：
class A{
public void getinfo(String name) {
System.out.print("父类getinfo方法" + name);
}
}
class B extends A{
public void getinfo() {
System.out.print("子类getinfo方法");
}
}
public class Test {
public static void main(String[] args) {
B b1 = new B();
b1.getinfo("AA"); //父类getinfo方法AA
B b2 = new B();
b2.getinfo(); //子类getinfo方法
}
}
属性覆写：
若子类定义了和父类相同的属性时，那么实例化后调用的是子类的属性，若要访问父类的属性，可以使用super.属性名：
class A{
public String name = "父类属性";
}
class B extends A{
public String name = "子类属性";
public void getinfo() {
System.out.println(super.name); //父类属性
System.out.println(this.name); //子类属性
}
}
public class Test {
public static void main(String[] args) {
B b1 = new B();
b1.getinfo();
}
}
覆写限制：
子类覆写父类方法或属性时，访问限制要和父类相同或更宽松：public > default > private。若父类是private修饰的则不能进行覆写（私有属性和方法子类不能直接调用）。
final关键字：
在JAVA中，使用final关键字可以定义不能继承的类、方法、常量。
public class Test {
public static void main(String[] args) {
public static final double PI = 3.141592653; //定义全局常量
}
}
三、Annotation注解：
@Override：
明确表示该方法是一个覆写来的方法：
class A{
public void getinfo() {
System.out.println("111111");
}
}
class B extends A{
@Override //加上此注解可以在编译时防止要覆写的方法单词写错了或继承父类没写。
public void getinfo() {
System.out.println("222222");
}
}
public class Test {
public static void main(String[] args) {
B b1 = new B();
b1.getinfo();
}
}
@Deprecated：
过期操作，用此注解修饰的方法表示此方法不建议使用（但能使用），已淘汰。但又不能直接删除此方法，因为以前的某些代码可能调用了此过期的方法。
@SuppressWarings：
压制警告，通过此注解修饰的方法在编译时如果有警告信息出现，如调用了过期的方法，可以使用此注解使其编译器不在显示警告信息。简单来说就是屏蔽警告信息。
四、多态性
多态是在继承性的基础之上扩展出来的概念，可以实现父子之间转换关系。
JAVA对于多态有两种实现模式：
方法的多态性：
1、方法重载：同一方法名称可以根据传入的参数类型或个数的不同实现不同功能。
2、方法覆写：同一个方法可能根据子类的不同有不同的实现。
对象的多态性：
1、对象向上转型：父类 父类实例 = 子类实例 ； 自动完成转换。
class A{
public void getinfo() {
System.out.println("111111");
}
}
class B extends A{
public void getinfo() {
System.out.println("2222222");
}
}
public class Test {
public static void main(String[] args) {
A a1 = new B(); //对象向上转型,自动转换
a1.getinfo();
}
}
2、对象9向下转型：子类 子类实例 = （子类）父类实例；强制完成转换。
在进行向下转型时，必须要进行向上转型。
五、Object类
使用object类可以解决参数的统一问题，也就说可以接受任何数据类型。
Object类是不存在有继承关系的，也就是说所有的类都是Object类的子类。
class A{}
public class Test {
public static void main(String[] args) {
Object obj = new A(); //Object类可以接受任何数据类型，是所有类的父类
Object obj1 = new String[] {"11","22"};
}
}
Object.toString()：
toString()方法可以获取对象信息，但默认返回的是对象内存编号：
class A{}
public class Test {
public static void main(String[] args) {
A a1 = new A();
System.out.println(a1.toString()); //A@15db9742
System.out.println(a1); //A@15db9742
}
}
可以通过覆写toString方法得到自定义对象信息：
class A{
public String toString() {
return "覆写toString()方法";
}
}
public class Test {
public static void main(String[] args) {
A a1 = new A();
System.out.println(a1.toString()); //覆写toString()方法
System.out.println(a1); //覆写toString()方法
}
}
Object.equals()：
可以使用此方法比较两个对象内容是否相同。
六、抽象类
对子类中覆写方法进行约定（子类继承后一定要覆写此方法），一般写父类都为抽象类。
使用abstract关键字定义的且没有提供方法体的方法。（就是规定了方法名，但方法体由子类自己实现）
abstract class A{
public abstract String getinfo();
}
class B extends A{
public String getinfo() {
return "子类必须覆写父类抽象类定义的方法";
}
}
public class Test {
public static void main(String[] args) {
}
}
七、包装类
之前说过Object类是所有类的父类，可以接受任意引用类型，但Object类不能接受JAVA的八种基本数据类型（int、long、double等），因为基本数据类型不是引用类型(类)，所以把基本数据类型包装成引用类型来使用就是包装类的作用。
JDK中包装类一共提供了两种类型：
对象型包装类（Object直接子类）：Boolean、Character；
数值型的包装类：（Number直接子类）：Byte、Short、Integer、Long、Double、Float
八、接口
可以理解为一个纯粹的抽象类（最原始的定义接口之中是只包含有抽象方法和全局常量）。
使用interface关键字定义接口，implements实现接口：
interface A{ //定义一个接口A
public static final String INFO = "111";//全局常量
public abstract String getinfo(); //抽象方法
}
class B implements A{
public String getinfo() {
return "222"; //必须实现接口的抽象方法
}
}
public class Test {
public static void main(String[] args) {
}
}
用接口可以实现一个子类可以实现多个接口：也就是多重继承。
九、包
为了方便类的管理（如类重名），JAVA采用包的机制来管理类。其实包相当于目录，用不同的目录保存类，在通过目录调用类。
package cn.a.demo; //定义包
public class Hello{
public static void main(String args[]){
System.out.println("Hello");
}
}
// javac -d . Hello.java 打包操作
//javac cn.a.demo.Hello 执行类包的导入：
使用import关键字导入相关包：
package cn.b.demo;
import cn.a.demo;//导入指定包的类
import cn.a.*;//使用通配符导入指定包的所有类
public class Demo{
public static void main(String args[]){
cn.a.demo.Hello h1 = new cn.a.demo.Hello(); //若导入的包有类重名，则使用全路径包名称
Hello h2 = new Hello(); //若导入的包没有重名的，则可以直接使用类名称
}
}
静态导入：
若要导入的包的类方法都是静态定义的，那么JAVA提供了静态导入方式：
package cn.a.test;
import static cn.a.demo.*; //静态导入
public class Test{
public static void main(String args[]){
add(1,2); //通过静态导入，使用时可以不加类名.方法()
}
}生成jar文件：
当项目完成后，会有大量的包及class文件，为了方便管理及使用，可以把这些包及class文件压缩成一个文件，这就是生成JAR文件：
生成命令：jar -cvf test.jar cn ：-c创建一个新的jar文件，-v信息输出，-f设置要生成的jar，cn包名
系统常见包：
java.lang：基础类，像String、Number、Object都在这里，系统会默认加载。
java.util：工具类，包括数据结构的定义
java.io：进行输入与输出流操作的程序包
java.net：网络程序开发的程序包
java.sql：数据库编程的开发包
java.awt、java.swing：JAVA图形界面开发包（GUI）