类、对象、封装

1、类模板：创建一类数据的模板，同一个.java文件多个类，可生成多个.class文件；
2、对象：由模板具体出的实例；new的过程中会向内存申请空间，与malloc类似；
3、封装：狭义上是对一个类型的所有行为的封装，即为类模板添加行为；

三大特性

1.封装：将类里的属性或实现细节隐藏起来，对外界提供公共方法
2.继承：子类继承父类所有非私有的属性和方法，父类不可以访问子类特有的属性和方法，并且是多态的前提
3.多态：一种事务运行的多种形态，多态的向上转型（父类引用指向子类对象），多态的向下转型。

构造函数、this、static函数

1、构造函数是在创建对象是使用；主要目的是给类成员变量赋值；无返回，默认无参，不被普通所调用；（比较独立的函数，不接受外界统治，只听命于对象创建）
2、this作用是类引用，是给编译器看的，不是本身具有的语法；当创建动态函数时，默认传入this，一般用于动态函数；

class Animal{
public Animal(){
    this("Tom");//调用含参构造器，前面不能有其他函数，必须放在第一位
}
}

3、static修饰的成员，当类模板被加载到内存中，就在方法区内创建；
非static修饰的成员，当创建对象时候才会在堆内存中创建；

static一般与this对比记忆

Static函数：类模板加载时候传入方法区、无this传入、类名调用；

动态函数：类对象创建时传入堆内存、隐含传入this、对象调用；

static语句块、动态语句块、局部代码块

1、静态代码块：static修饰的非局部代码块，在类加载过程中执行；
static{
    //类加载中执行
}

2、动态语句块：创建对象的时候执行，并且在构造函数之前执行；
{
//创建对象时执行，构造函数之前执行；
}（应用的较少）

3、局部代码块：定义在方法中的代码块，主要为了限制局部变量的声明周期；
public static void main(String[] args) {
{
//定义在方法中代码
}

}

内部类

成员内部类：

1、非static内部类

class OutClass{
    //this指针就是对象的引用
    int x,y;
    class Inter{
        void show(){//在非static中，隐含传入外部类的this和内部类的this 
        }
    }
}

2、static内部类

class OutClass{
    int x,y;//类模板下的变量公共变量，需要被对象this指针引用从而使用；
    static int z;//可以理解为类模板自己的变量，独一份存在方法区；
    static class Inter{
        //静态方法中只能调用类模板自己的变量，因为他不能传入外部this指针
    }
}

四个代码块比较

//执行顺序如下
1.静态代码块：只执行一次、

static{
//静态代码块
}

2.普通代码块（构造代码块代码块）：每新建一个对象都会执行一次

class A{

{
//
}

}

3.构造函数

4.普通函数;

public void show(){
}

匿名内部类：没有名字的内部类。
☆匿名内部类是不存在构造器的
☆ 匿名内部类可以是匿名成员内部类，也可以是匿名 局部内部类
1、通过接口和抽象类,普通类来创建匿名实例

2、父类有抽象方法，匿名内部类必须继承； 

public abstract class Out {
    public abstract int getN();

    static Out Inner = new Out(){//1、Inner是外部类Out的定义
        @Overreide
        public int getN(){ }

        int nn;//2、外部类是得不得匿名内部类的变量，只能通过继承父类的方法
    }；//3、特殊符号

}

权限修饰符

可修饰的内容：类、成员属性、成员方法、枚举、接口、注释

一般需要继承的东西用 protected；
一个.java文件中用public修饰的只能是一个；

单例模式

目的是保证内存中只有一个实例；
方法：private对构造函数限制，static调用；

方法1
public class SingleDemo{
    private SingleDemo(){
    }//私有的构造函数，只能在本类中被调用；
    private static SingleDemo single = new SingleDemo();

    public static SingleDemo getsingleDemo(){
    return single;
}

}

方法二
private static SingleDemo single;
private SingleDemo(){
    if(single==null){
        single = new SingleDemo();
}
}
public static SingleDemo getsingleDemo(){
    return single;
}

继承

主要目的：减少代码量

1、继承的子类在创建是会先调用自己构造函数中super();(父类的构造函数)进而先调用父类构造函数里面的内容；

2、继承关系可以无限延伸；
3、
4、父类型指向子类型的对象

大类型   小类型
父类     子类
当用父类型指向子类型实例的时候，编译器无法识别对象本身的类型，只能处理父类模板中所包含的成员变量；

//父类
public class Car {
    String type;
    String name;
    public Car() {

    }
}
//子类
public class Bin extends Car{
    public static void main(String[] args) {

        Bin b = new Bin();//用Bin接受 Bin()中的数据（父类型指向子类型的对象）
        Car bi = new Bin();//用Car接受 Bin()中的数据，小类型向上造型，，只能提取Car中的数据；
}
}

//若想调用子类模板中成员，需要强制转换后调用;如果类型转换出错，抛出ClassCaException；

 Car c = new Bin();//new Bin的对象c，由于无法识别c的类型，只能是Car类型中的变量；
 Bin ca = (Bin)c;//大类型c强转为小类型Bin；

//子类的子类
Class BinOne extends Bin{

    public BinOne(){
            super();//super包含两个父类的super内容，如果内容重名，就近原则调用Bin下的变量；
    }
}