封装：
是将数据和行为组合在一个包内，并对对象的使用者隐藏了数据的实现形式。
封装是把一个对象的属性私有化，同时提供一些可以被外界访问属性的方法！
优点：可以对成员进行更精确的控制。隐藏信息，实现细节。
因为基础类型在栈中存储值，**封装类型在栈中存储引用(对象)，在队中存储值！**确实比基础类型存储起来要麻烦得多，但是保证了安全性以及复用性！
private可以修饰成员变量也可以修饰成员方法；
修饰成员变量时，只能被本类访问，不可以被外部访问。
1.自动装箱和自动拆箱：
float f = 66.6f;
//自动装箱
Float f1 = new Float(f);
//自动拆箱
Float f2 = f;
Double d = new Double(88.88);
//手动拆箱
double d1 = d.doubleValue();
//自动拆箱
int score = 67;
//装箱(封装)
Integer score1 = new Integer(score);
//拆箱并转换类型
double score2 = score1.doubleValue();
float score3 = score1.floatValue();
int score4 = score1.intValue();
2.转化成String的方法，以及str转化成double的方法：
double a = 78.5;
//转化成String的方法
String str = String.valueOf(a);
System.out.println("str + 12 的结果为： "+(str + 12));
String str1 = "180.20";
//str转化成Double以及Int的方法
Double dd = Double.parseDouble(str1);
System.out.println("d + 100 的结果为： "+ (dd + 100));
3.使用场景：
(1)类型转化：
String b = “123”;//如果含有非法字符，则会报错！
Int c = Integer.parseInt(b);
(2)泛型中使用：
List<>为原始类型，不指定元素类型时，会警告；所以List的<>中应该指定清楚的类型，如Integer，String等!
(3)强制类型转化；
4.优点
(1)类内部的就够可以自由修改；
(2)可以对成员变量进行更精确的控制！
(3)隐藏信息，实现细节，代码复用性极强！
5.泛型：
//不使用泛型：
List list1 = new ArrayList();
list1.add(“www.educoder.net”);
String str1 = (String)list1.get(0);
使用泛型：
List list2 = new ArrayList();
list2.add(“www.educoder.net”);
String str2 = list.get(0); //可以发现在这里我们不用强制类型转化
提高性能，代码更安全
继承：
class 子类名extends父类名 [implements <接口名>]｛}//extends就是子类继承父类
(java.lang.)Object 类。//默认定义的所有类的父类
Java中只能继承一个父类
1.子类继承父类中已有的成员变量和方法；
2.子类可以增加父类中没有的变量和方法，或修改父类中已有的变量和方法。
3.方法覆盖(方法重写)指子类的方法与父类的方法名相同，方法的返回值类型、入口参数的数目、类型、顺序均相同，只是方法实现的功能不同，此时父类的方法被覆盖。
4.方法重载：同一个类中类名相同，方法体不同，参数不同；
5.this关键字的使用：
(1) 调用成员变量
(2) 调用成员方法
(3) 调用构造方法
(4)区分成员变量和局部变量
(5)返回实例对象本身的使用
(6)在构造方法中使用其他构造方法
(7) 对象的比较：
// 调用此方法时里面存在两个对象：当前对象、传入的对象
Person p1 = this ; // 当前的对象，就表示per1
Person p2 = per ; // 传递进来的对象，就表示per2
if(p1==p2){ // 判断是不是同一个对象，用地址比较
return true ;
}
6.super的使用：(访问父类被隐藏的变量以及覆盖父类方法)
super.talk(), super.a;
//1.调用父类构造方法
//2.调用父类被覆盖的方法
//3.访问父类中被隐藏的成员变量
注意：
父类不含无参构造方法时子类构造方法必须显式调用父类带参构造方法，因为子类实例化的时候先需要实例化父类
例：
package tett;
public class Ex_SuperUse {
static int n = 10;//A行
public static void main(String[] args){
SubClass sc2 = new SubClass(n);
}
}
class SuperClass{
private int n;
SuperClass(int n){
System.out.println("SubClass("+n+")");
this.n = n;
}
}
class SubClass extends SuperClass{
private int n;
SubClass(int n){
super(n);
//就是说当父类有无参构造方法时，子类构造方法会隐式的调用它，所以可以不写，但是当父类有有参构造方法时，子类有参构造方法必须调用它，并用super调用它！
System.out.println("SubClass("+n+")");
}
}
7.对象类型转换：
Animal animal = new Dog();
Dog dog = (Dog) animal; // 向下转型，把Animal类型转换为Dog类型
Creature creature = animal; // 向上转型，把Animal类型转换为Creature类型
1.向上转型：
(1)//父类有的子类也有的才可以调用
(2)上转型对象不能操作子类新增加的成员变量和成员方法。
(3)上转型对象可以代替子类对象调用子类重写的实例方法。
(4)上转型对象可以调用子类继承的成员变量和隐藏的成员变量。
//继承成员变量：父类int a; 子类 int a;
//隐藏成员变量：父类int a; 子类 double a;
子类对象向上转型为父类对象是安全的。
2.向下转型：
(1)//可以调用子类的所有方法（包括父类的方法）
(2)向下转型对象访问重写父类的方法时，操作的是子类的方法。
(3)向下转型对象可以操作父类及子类成员变量和成员方法。
(4)向下转型必须保证父类对象引用的是该子类的对象，如果引用的是父类的其他子类对象，会抛出类型不匹配异常。
注意：：父类对象向下转为子类对象是不安全的；编译不会出错，但是运行时会出现java.lang.ClassCastException错误。它可以使用instanceof来避免出错此类错误即能否向下转型，只有先经过向上转型的对象才能继续向下转型。
多态：(通过继承和接口实现多态)
定义：即不同类的对象收到相同的消息时，得到不同的结果。
即多态性也分静态多态性(编译时的多态)和动态多态性(运行时的多态)；
静态多态性是指定义在一个类或一个函数中的同名函数，它们根据参数表（类型以及个数）区别语义和执行的功能。
动态多态性是指定义在一个类层次的不同类中的重载函数，它们具有相同的函数原型，需要根据指针指向的对象所在类来区别语义，它通过动态联编实现。
非访问控制符：
除了可以使用 public、private、protected 和默认来设置类成员变量,还可以使用 static、final、abstract 等说明成员变量或方法的特性。