权限修饰符：
修饰范围：属性、方法、构造方法
（构造方法也能私有，那我们咋创建对象啊，哼哼，别人不能创建，我自己创建呗，别人得经过我同意才能得到这个对象仅此一个（这叫单例设计模式））
代表的权限
public： 本类 同包 子类 任意类
protected： 本类 同包 子类
默认（无）： 同包 子类
private：子类
（以上表示被其修饰的元素能被谁访问）
特征修饰符：
a.abstract
修饰范围：方法，类
修饰了方法后，不能有方法块，子类必须重写
b.final
修饰范围：
属性：修饰后必须要被赋值并且只允许赋值一次
方法：不能被子类重写
类：不能被继承，我们接触的很多工具类，都是final修饰的，如String Math Scanner Integer Float Double
规定：
final修饰的成员变量必须显示指定初始值（显示初始化）
但它说的不可变仅仅知识地址不可变，地址所对应的对象的内容可以变化，
比如final修饰数组里面单位值是可以变的知识，引用不能再看其他男人。比如final修饰的类，里面的属性，可以通过方法等方式进行改变（你得到了我的身体却没得到我的灵魂）
c.
static
修饰范围：属性、方法、块、成员内部类
修饰特点：
1.修饰的元素存储在静态元素区内
2.加载的很早，在类初始化时候就加载
3.静态元素有且只有一份，全部类对象包括类本身共享
4.通过类名字就可以访问
5.不能被GC垃圾回收器回收，常驻内存
6.静态元素可以访问静态元素
7.非静态元素可以访问静态元素
8.静态元素不可以访问非静态元素
（原因：成员之间直接访问需要用this ，但是this：1.代表了调用方法的对象，2.正在初始化的对象，两者都是对象，在static中你this.非静态元素，这个this.指向的是那个类，无法指向合适的对象（看看逻辑冲突了，这是不符合this的规定的）so static修饰的方法不能用this引用，没有的this你就不能调用到对象的非静态元素，所以java语法规定静态成员不能访问非静态成员
9.静态对象不属于对象，属于类
10.静态元素中不能使用this和super（原因如上）
其他：
native:这里修饰的方法调用本地语言编写的程序（通过c或其他底层语言操作内存）源码翻到这里就是java的最底层了
synchronzied:同步，线程锁
volatile：不稳定（处理并发问题，线程并发问题后面讲）
transient：瞬时（序列化问题）
this 和super区别：
this：
1.总是指向调用该方法的对象
2.作为对象的默认引用有两种情况：构造器中引用构造器正在初始化的对象、在方法中引用调用该方法的对象
public Person（String name）{
this.name=name;
//这个this相当于下面的p
}
person p =new person(String name)
3.可以调用 属性 方法 构造方法
4.位置：可以出现在任意位置，代表对象调用属性、构造方法this()
5.通过this 调用构造方法问题：
（1）只能放在另一个构造方法内，不能出现在普通方法块里面，
（2）位置上只能放在第一行
（3）构造方法之间不能来回调用会产生栈内存溢出异常
public class TextMain {
public static void main(String []args){
new Person();
}
}
public class Person {
public Person(){
new Man();
}
}
public class Man {
public Man(){
new Person();
}
}
Exception in thread “main” java.lang.StackOverflowError
原因：
首先方法的执行会在栈内存开辟一块内存空间，person构造方法执行man的构造方法，man构造方法执行调用person构造方法，互相调用但原来的方法依然在执行没有得到完成和释放，这样一直套娃到，栈内存满员
super：
1、子类（重写了父类的方法后）子类对象本身无法访问重写了父类之后的方法super能代表父类对象调用已经被重写的方法
public class Person extends Man{
public Person(){
}
public void say(){
System.out.println();
}
public void sayPerson(){
super.say();//输出man
}
}
public class Man {
public Man(){
}
public void say(){
System.out.println("man");
}
}
2、子类可以通过super（）来调用父类构造器里的初始化代码，（一个构造器调用另一个重载的构造器用this调用来完成），确实加载子类是会偷偷调用父类的无参数构造器，
但是有时候子类想调用父类其他特殊的构造方法，可以通过super（信xxx,xxx）来完成自己的需求
super与this相像点：
1.this代指调用方法、属性时的那个对象，super代指当前对象的父类对象
2.使用起来都一样，可以调用一般属性和一般方法
3.放置在类成员的任意位置
4.调用方法时候来回调用 可能会产生运行时错误StackOverflowError
5.调用构造方法只能放在另一个构造方法里，并且只能放在第一行
类与类的关系：
1.A is a B （继承实现）
2.A has a B（对象作为一个类属性）
3.A use B（一个的类对象放置再另一个类的方法中使用）
面向对象三大特征：
一、封装
（一）定义：
将对象的状态信息隐藏在对象内部，不允许外部程序直接访问对象内部信息，⽽是通过该类所提供的⽅法来实现对内部信息的操作和访问。
（二）目的：
1.追求高内聚低耦合
高内聚：
模块的内部数据，功能实现细节隐藏与模块内部内部独立完成不允许外部直接干预。
低耦合：
仅仅暴露少量方法给外部使用
2.隐藏类的实现细节
3.限制不合理访问：让使用这只能通过预先预定的方法来回访问数据，从而可以再改方法里加入控制逻辑
4.可进行数据检查，从而有利于保证对象信息的完整性
5.便于修改，提高代码的可维修性（哪里出问题直接找这个问题所在的类和方法就OK）
（三）如何封装：
属性私有，只给外部暴露赋值和取值的方法
（四）封装的原则：
1.复用性（无冗余结构）
2.健壮性（逻辑严谨，尽量覆盖多的问题解决）
3.执行性能（循环内存）
4.可读性（代码层次 命名规范 注释）
二、继承
（一）作用：
是实现类复用的手段（一个类通过各种继承能实现多种业务）但他一定程度上与父类的封装性有所矛盾
（所以为了保护⽗类的封装性，设计⽗类有如下规则：（代码规范）所有成员变量⽤private修饰，不让⼦类直接访问⽗类的成员变量内部⽅法private 修饰，或者 public final 共同修饰不要在⽗类构造器中调⽤将被⼦类重写的⽅法）
（二）特性：
1.子类和父类 通过extends （扩展）来实现
2.子类可以调用父类中成员 public protected
3.子类添加独有成员
4.子类继承父类的方法不能满足自己的需要，可以进行方法重写overreide
5.类的继承要求单继承
6.每个类都默认继承一个Object类（上帝类）
Object类介绍（初学者可以先做了解）
Object类有8大方法，有些在日后的开发中可能经常会做些重写
(1)equals（Object obj）//判断地址是否相同
(2)hashcode（）；将对象在堆内存的数据转换成hahscode码（类名@进制码）
（int类型）
(3)getClass() //获取类模板（返回值：Class类型）
(4)wait()//线程等待
(5)notify()//唤醒线程
(6)finalize()//对象被回收时候
(7)clone() 可以产生一个相同的类并且返回给调用者
三、多态：
1.基础
引用变量有两个类型：
（1）编译时类型：由声明变量时候使用的类型决定
（2）运行时类型：有实际赋给该变量的对象决定
2.定义：
多态就是编译时类型和运行时类型不一致（父类的引用指向子类的对象）
一个对象在内存中体现出多种不同的形态
想要有多态需要先继承
多态后的结果：属性是父类的属性，方法还是父类的方法，如果子类有重写那就是子类
3.如何调用子类独有方法
需要将身份还原回去（造型也可叫做强制类型转换）
4.相关问题
造型时候制造的类型与真实对象类型不匹配（ClassCastException）
提前使用instance of类判断
四重写与重载的区别：
两者最大区别：在名字一样的情况下，重写参数必须一样，重载参数必须一致。
其实两者的区别没必要死记硬背，技术要考理解，没一个靠背知识点和代码的程序员能活的下去，这样子编程这件富有创造的的事也失去了原本的好看模样。
他两某种程度上都是方法的服用，只是一个发生在父子类之间一个发生在同类之间。
子类权限更宽松，子类权限比父类严苛这是不现实的，不能说子类是protect 父类是private，父类权限高，子类可能都继承不了
同一个类不能有同样的方法，在方法名同样的情况下甄别他们的最好方式是参数。
