最最基础内容：
类格式：
Public class 类名（）{}
方法体格式：
Public void（static）方法名（）{}
类与对象
类：对具有相同具体特征对象的一个抽象
对象：对一个类具体化或者实例化
类的创建：
Public class 类名（）{
可以写属性，方法
//创建对象的语法格式
类名 对象名=new 类名（）；
//访问属性的语法格式
对象名.属性名
//访问属性的语法格式：
对象名.属性名
}
成员变量与局部变量
成员变量：类中的成员，类创建以后，会自动赋予初始值
局部变量：方法中的变量，使用时需要赋初始值
关于生命周期：
成员变量与对象生命周期相同
局部变量会与相应方法的生命周期相同
数据类型：
字符型：byte，short,int，long,float,double
字符型：char
布尔型：boolean
值类型：int,byte,short,long,float,double
引用类型： 例子Student student=new Student();
数据类型的参数传递
- 具体数据类型的参数传递，
例子：
Int num1=10;
Modify(num1);
- 引用数据类型的参数传递
Stu.name=”张三”;
Stu.age=20;
Modify(stu);
封装
为什么：
为不让其他类直接访问类的属性，需要对类进行封装，避免对象属性赋值的随意性
类的基本封装
关键字：private
封装后无法随意读取与赋值，需要set对象名，赋值,get对象名，获取值
不封装方法为public方法，可以随意访问，随意赋值，称为公有属性，封装了以后的方法是无法随意改动与读取，称为私有属性，可以根据具体情况只提供一种对外方法，即属性可读可写。对类的封装提高了属性访问安全性。
属性的验证赋值
实际是用判断语句去改写，验证
this关键字
我们以一个例子来说明
public void satName(String name){
this.name=name;
}
这里的的this代替了class的名称，解决了局部变量与成员变量重名的问题。this.name是成员变量,name是局部变量
构造方法：
格式：修饰符 构造方法名（参数列表）{代码块}
定义：创造对象时执行的方法，只要在new对象时，就知道其执行的构造方法是什么，就可以在执行这个方法的时候给对象进行属性赋值
构造方法的体现：
- 构造方法没有返回值类型，不需要返回值，因为它用于构造对象，对象构造完，方法就结束了。
- 构造方法名称必须与类型保持相同
- 构造方法没有具体返回值
例子：
public class Student {
//id是学号,name姓名,grades成绩
private String name;
private Double grades;
public Student(String name, Double grades) {
this.name = name;
this.grades = grades;
}
public Student() {
}
@Override
public String toString() {
return name+grades;
}
}
构造方法的调用：
Student student=new Student(23,”张三”);
System.out.println(name+age);
继承
关键字：extends
概念：不同类中具有相同属性与方法，可以将相同的属性与方法提取出来，放入一个新的类中，称之为父类，然后子类继承父类具有父类的属性或者方法，然后子类就不需要定义这些方法了
使用：
例子：
Class Persion(){
String name;
Int age;
}
Class people extends persion (){
Int son;//此时people中具有父类的属性
}
注意事项：
- java中只可以单继承，不能多继承，也就是一个子类只能有一个父类
- 多个类可以继承一个父类
- 允许多层继承
子父类成员变量的特点
关键字：super
如果子类与父类具有相同属性，如果要访问父类的属性，需要用super关键字引用
例子：
* class Father(){
* int num=3;
* }
*
* class Son(){
* int num=9;
* void show(){
* System.out.println("Father num"+super.num);
* }
* }
子父类的成员方法特点
当子类与父类有相同方法时，子类会自动覆盖父类方法，称为override重写，这样即沿袭了父类的功能又定义了子类特有内容
注意：
- 子类方法覆盖父类方法，要保证权限大于父类
- 子类方法和父类方法声明时必须一模一样，也就是返回类型，方法名，参数排列都要一样
子父类中构造方法的特点
创建子类时，因为子类对象继承父类的成员比变量和成员方法，所以子类会先加载父类，调用父类的构造方法，在第一行就会默认调用父类的构造方法
抽象类与接口
关键字：abstract
概念：在一个类中，所有方法只有方法名，没有方法体的类
使用：用子类继承使用（extends）
抽象方法定义格式：public abstract 返回值类型 方法名（）{}
抽象类定义格式：abstract class 方法名{}
抽象类特点：（1）抽象类和抽象方法都是用abstract修饰，抽象方法一定在抽象类中
（2）抽象类不可以直接创造对象，其原因是创造对象没有实际意义
- 只有覆盖了抽象类中所有的抽象方法后，其子类才可以创造对象，否则该子类还是一个抽象类
- 抽象类中不定义抽象方法。
接口
关键字：interface
概念：接口是功能类，看看作一种数据类型，是比抽象类更加抽象的类。
使用：用implements声明
接口类定义的格式：
Public interface 接口名{
抽象方法1；
抽象方法2；
...............
}
注意:子类必须覆盖接口中所有的抽象方法后才可以实例化，否则子类是一个抽象类
特点：
- 一个类的实例化既可以继承父类，又可以实例化接口
- 接口可以继承多个接口
- 如果多个接口存在相同方法，同时有个子类实现这个这些接口，那么这个子类就实现接口中的方法。由于接口中的方法是抽象方法，子类实现后就不会发生调用的不确定性。
类的多态
三大特性：封装，继承，多态
多态概念：继承父类的子类，具有子类与父类的两种形态，称之为多态
前提：必须有父类的继承关系，或者有实现接口的关系
定义格式：
父类类型（或者接口名称） 变量名=new 子类类型（）；
变量名.方法名（）；
特点：
- 同一个父类被不同子类重写。在调用时，调用的为各个子类重写后的方法。
- 在多态中父类变量只能访问父类的成员变量，而父类变量却是调用子类对象的方法，这也是体现其多态性
多态转型
多态转型分类：向上转型和向下转型
向上转型就是多态:
格式：
父类类型（或者接口名称） 变量名=new 子类类型（）；
向下转型：将一个向上转型的子类对象向下转型，可以使用强制转型的格式，将子类转化为父类引用。
格式：
子类类型 变量名=（子类类型） 父类类型的变量
注意:instanceof可以判断对象是否属于某种类型
总结：如果使用父类的功能就能完成相应操作，就可以使用向上转型，如果使用子类特有功能就要向下转型
类的高级特性：
- Static修饰符
特点：
- 可以不创建对象，直接通过类名访问调用方法与属性
例子:
public class Student {
String name;
int age;
static String school;
static void showInfo(){
System.out.println("静态方法");
}
}
public class Demo {
public static void main(String[] args) {
Student.school="南开";
Student.showInfo();
}
}
本质：被static修饰的成员属于类，不属于对象，所以可以直接采用类名.成员的方法访问，
被static修饰的成员变量与成员方法被称为静态变量或者静态方法
- 当其中一个对象修改了变量的值，即所有对象共享静态变量的值。
Final修饰符
使用范围：可以用来修饰类，类成员，局部变量
使用后的特点：修饰类不可被继承。修饰方法后方法功能固定，不被子类重写。
特点：
- final修饰类不可以被继承，但是可以继承其他类
- final修饰的方法不可以被覆盖，但是父类中没有被final修饰的方法，子类覆盖后可以加final
- final修饰的变量为常量，只能赋值一次
- final引用的变量值为对象地址值，地址值不能修改，但是地址内的对象属性值可以修改（就是可以修改里面的数据）
例子：final Person p1=new Person();
Person p2-new Person();
p1=p2;（p1的地址值仍然不变，不信可以打印一下哈希码对比哈希码）
p1.name=”小米”;（可以修改p1里面的属性的值）
- final修饰乘员变量时，需要创建对象前赋值，否则报错。（简单来说就是创建最终对象时要赋值）
- 在java中，同时使用public static final修饰的变量，变量名需要大写,多个单词需要用下划线连接
例子:
public static final int T=20;
- 接口中成员变量默认为public static final 修饰的。接口中的成员变量是静态变量，由于接口们没有构造方法，所有必须显示赋值。访问成员变量时可以直接使用接口名
代码块：
分类：局部代码块，构造代码块，静态代码块
- 局部代码块：
定义在方法或语句中，以{}为划定的代码区域，此时只需要关注作用域，方法与类都是以代码块划定边界的。
- 构造代码块：
构造代码是定义在类中的成员位置的代码块，优先与构造函数执行，构造对象是对所有对象初始化的动作，每创建一个对象就会执行一次构造代码块
- 静态代码块：
静态代码块是定义在成员位置中，使用static修饰的代码块，静态代码块优先于构造代码块执行，当第一次使用该类时就会执行，无论创建多少对象静态代码块都只执行一次
匿名对象
创建匿名对象时，只有创造语句，没有把对象地址赋值给某个变量。
匿名对象使用：
- 创建匿名对象直接使用，没有变量名，只能使用一次
例子：new Person().eat();
- 匿名对象可以作为方法接收的参数，方法返回值使用。
例子：class Person2{
Private String name;
Private int age;
}
Class Tools{
Public static Person2 getPerson(){
Return new Person2();
}
Public static void methop( Person2 p);
}
Class Demo(){
Public static void main(String [] args){
Tools.method(new Person2());//匿名对象作为方法接收参数
}
}
内部类
分类：内部类，方法内部类
- 成员内部类
在一个类中定义的类，可以访问外部类的所有成员，内部类可以创建属于自己的类。
例子：
Class outer(){
Int x=100;
Class Inter{//成员内部类
Void show(){
System.out.println(“x=”+x);
//可以访问外部类的成员变量和方法。
}
}
Public void test{
Inter inter =new Inter;
Inter.show();
}
}
Public class Demo(){
Public static void main(String [] args){
Outer outer=new Outer();
Outer.show();
//创建内部类方法
Outer.Inter inter=new Outer().new Inter();（格式）
Inter.show();
}
}
- 方法内部类
概念：
在成员方法内定义的类。只能在当前方法中使用。
用法：在外部类方法中创建的类，只能被此方法访问。
例子：
Class Outer{
Int num=10;
Public void test(){
Class Inter{
}
Inter inter=new Inter();
Inter.show();
}
}
Public class Demo{
Public static void main(String [] args){
Outer outetr=new Outer();
Outer.test();
}
}
