JAVA零散知识（推荐学习一段时间的萌新阅读）

JAVA一些零散知识总结一波（推荐萌新们看看，我自我感觉总结的不错，不喜勿喷）可在学习完一段时间基础知识后，回来看看这篇文章，巩固一下；
（字数3747，阅读完大约15min）

break是直接跳出当前循环
countinue是跳过本次循环，进入下一次的循环

字符串的比较
'=='是比较两个字符串变量是否指向同一个字符串对象
‘equals()'是比较两个字符串变量指向的字符串是否相等

float和double的区别：float 三十二个比特 double六十四个字节 小数默认是double类型 若想 float a = 0.1 不报错，可这样写：float a = 0.1f
函数重载不对数据类型关注，只关注参数的变化:函数重载只关系参数列表的变化；

非静态变量，形参不影响实参；

所有子类会先用spuper()调用父类的构造器，再调用自己的构造方法：即若创建一个子类的对象，会先调用父类的构造器，在调用子类自己的构造器；

转型对象无法使用对象的新增方法，只能使用继承和重写的方法。：例子：若向上转型，如：Animal是父类，Cat是子类 Animal a = new Cat(); 则a只能调用Animal类里的方法，不能调用Cat类里特有的方法。

final方法一旦生成，就不能修改，子类只能继承，无法修改
final类无法被继承

方法的重载
有关：与参数的个数有关
与参数的类型有关
与参数的

局部变量和成员变量
1.定义的位置不一样
局部变量：在方法的内部
成员变量：在方法外，类内
2.作用范围不一样
局部变量：只有方法中才可以使用，出了方法就不能再用
成员变量：整个类全都可以用
3.默认值不一样
局部变量：没有默认值，如果想要使用，必须手动进行赋值
成员变量：如果没有赋值的话，会有默认值，规则和数组一样

方法的参数也是局部变量，但是在调用方法时，方法的参数一定会被赋值
4.内存的位置不一样
局部变量：位于栈内存
成员变量：位于堆内存
5.生命周期不一样
局部变量：随着方法进栈而诞生，随着方法出栈而消失
成员变量：随着对象创建而诞生，随着对象被垃圾回收而消失
一般来说，局部变量的生命周期比成员变量短

怎么访问类中的private成员变量呢？
可以在类内定义两个函数：setXXX（）和getXXX（）
注意：setXXX函数不能有返回值，这是给private变量赋值的函数
getXXX函数不能有参数，返回值类型和参数类型相同
对于基本类型中的bool型，它的getXXX需要写成isXXXX（）

当方法的 局部变量和类的成员变量名字重合的时候，根据‘就近原则’，优先使用局部变量
如果需要访问本类当中的成员变量，需要使用格式：this.成员变量名

1.构造方法的名称必须和所在类的名称一摸一样
2.构造方法不要写返回值类型，连void都不写
3.构造方法不能return一个具体的返回值
4.如果没有编写任何构造方法，那么编译器将会默认赠送一个构造方法 public 类名(){}
5.一旦编写了一个构造方法，那么编译器将不再赠送构造方法
6.构造方法是可以进行重载的，重载：方法名称相同，参数列表不同

一个标准的类由下面四个部分组成
1.所有成员变量都要用private关键字修饰
2.为每一个成员变量编写一堆Gettte/Setter方法
3.编写一个无参数的构造方法
4.编写一个全参数的构造方法。

如果一个成员变量使用了static关键字，那么这个变量不再属于对象自己，而是属于所在的类，多个对象共享同一份数据。

一旦使用static修饰成员方法，那么这就成为了静态方法，静态方法属于类。
如果成员方法没有static关键字，那么必须首先创建对象，然后通过对象才能使用它；

静态不能直接访问非静态：
静态方法中不能使用this,super关键字;

静态代码块的格式是：
public class 类名称{
static {}
}

当第一次用到本类时，静态代码块执行唯一的一次
静态内容总是优于非静态，所以静态代码比构造方法先执行。
静态代码块的典型用途：用来一次性的对静态变量进行赋值。

在父子类的继承关系中，如果成员变量重名，则创建子类，访问由两种方式：
1.直接通过子类对象访问成员变量
等号左边是谁，就优先用谁，没有则向上找
2.间接通过成员方法访问成员变量
该方法属于谁，就优先用谁，没由则向上找

局部变量：直接写成员变量名
本类的成员变量：this.成员变量名
父类的成员变量：super.成员变量名

在父子类的继承关系中，创建子类对象，访问成员方法的规则：
创建的对象是谁，就优先用谁，如果没有则向上找
注意：无论是成员方法还是成员变量，如果没有都是向上找父类，而不是向下找子类

方法的重写（覆盖）：在继承关系中，方法名称一样，参数列表也一样。
方法的重载：方法的名称一样，参数列表不一样。
方法覆盖的特点：创建的是子类对象，则优先用子类的方法

方法覆盖的注意事项：
1.必须保证字符类之间的方法的名称相同，参数列表也相同。
2.子类方法的返回值必须小于等于父类方法返回值的范围
eg：如父类返回值的范围为：java.lang.Object，则子类的方法的返回值可为String
3.子类方法的权限必须【大于等于】父类方法的权限修饰符。
注意：public>protected>(default)>private dafault就是什么都不写 eg：直接 int num

继承关系中，父子类构造方法的访问特点：
1.子类构造方法当中有一个默认隐含的“super()”调用，所以一定是先调用的父类构造，后执行的子类构造；
2.子类构造可以通过super关键字来调用父类重载构造；
3.super的父类构造调用，必须是子类构造方法的第一个语句，不能一个子类构造调用多次super构造。

super关键字的用法有三种：
1.在子类的成员方法中，访问父类的成员变量
2.在子类的成员方法中，访问父类的成员方法
3.在子类的构造方法中，访问父类的构造方法。

this关键字的用法：
1.在本类的成员方法中，访问本类的成员变量
2.在本类的成员方法中，访问本类的另一个成员方法
3.在本类的构造方法中，访问本类的另一个构造方法

如何使用抽象类和抽象方法：
1.不能直接创建new抽象类对象
2.必须用一个子类来继承抽象方法
3.子类必须覆盖重写抽象父类当中所有的抽象方法
覆盖重写：子列去掉抽象方法的abstract关键字，然后不上方法体，大括号
4创建子类对象进行使用。

一个抽象类不一定含有抽象方法，只要保证抽象方法所在的类是抽象类；

接口的注意事项：
1.接口中的抽象方法，修饰符必须是固定的关键字：public interface
2.这两个关键字修饰符，可以选择性的省略；
接口不能直接使用，必须要有一个实现类来实现
public class 实现类名 implements 接口名{}

1.接口的默认方法，可以通过接口实现类对象，直接调用
定义：public default 返回值类型 方法名称
2.接口的默认方法，也可以被接口实现类进行覆盖重写
备注：接口中的默认方法，可以解决接口升级的问题；

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

私有方法就是只有类中的方法能够调用的方法
普通私有方法：解决多个默认方法之间重复代码问题
格式： private 返回值类型 方法名称（参数列表）{方法体}
静态私有方法，解决多个静态方法之间重复代码的问题
格式：private static 返回值类型 方法名称（参数列表）{方法体}

接口中的常量：
格式：public static final 数据类型 常量名称 = 数据值
1.接口中的常量，可以省略public static final
2.接口当中的常量，必须进行赋值，不能不赋值；
3.接口中常量的名称，使用完全大写的字符，用下划线进行分隔；

接口是没有静态代码块或者构造方法的
一个类的直接父类是唯一的，但是一个类可以同时实现多个接口，即一个实现类可以同时实现多个接口里的方法；

如果实现类所实现的多个接口中，存在重复的抽象方法，那么只需覆盖重写一次即可
如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类
如果实现类所实现的多个接口中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行反映该重写
如果一个类直接调用的方法，和接口当中的默认方法产生了冲突，则优先用父类当中的方法

多态的写法

1. 父类名称 对象名称 = new 子类名称（）
   2.接口名称 对象名称 = new 实现类名称（）

直接通过对象名称访问成员变量，看等号左边是谁，优先用谁，没有就向上找

成员方法：编译看左边，运行看右边
成员变量：编译看左边，运行还看左边

对象的向上转型，其实就是多态写法：
格式：父类名称 对象名 = new 子类名称（）；
右侧创建一个子类对象，把它当成父类来看待使用

对象的向下转型，其实就是一个还原动作：
格式： 子类名称 对象名 = （子类名称） 父类对象；
注意：
a.必须保证对象本来创建的时候，就是猫，才能向下转型成为猫
b.如果对象创建的时候不是猫，现在非要向下转型成为猫，则会报错；

final的常用四种方法：
1.可以用来修饰一个类
2.可以用来修饰一个方法
3.可以用来修饰一个局部变量：若是基本类型，则是值不能变，若是引用类型，则是地址值不能发生变化，但是里面的值可以发生改变；
4.可以用来修饰一个成员变量

喜欢的点个赞呗！
求关注！！！