一、抽象：

二、封装：有了封装才有数据类型！个体更多的设置为封装体，这样更加安全。该公开的公开(方法)，该隐藏的隐藏(属性)，配置一个访问窗口

方法的调用(按值传递和按引用传递)

1、在栈中分配空间(暂时给方法分配栈空间，执行完毕后就消失，注重内存的画图分析)

内存分为代码空间(方法的代码)和数据空间，方法在数据空间还保存有方法的地址

2、传参

3、执行

三、继承：确定父类和子类is-a(关系)

在子类中自己定义一个构造方法时，当父类的属性时private时，我们就不能直接定义自己构造方法的属性(？怎么做：)；第一种方法是通过调用父类的public的方法来定义属性；第二种方法是：所有的父类构造方法是public的，所以我们可以通过super(参数)这个表达式类调用父类的构筑方法！！

任何子类的构造方法都会去调用f父类的构造方法！(就算自己不写也会调用！而当程序员没有写构造方法是，系统就会自动定义一个无参的构造方法public Birld(){super()；}所以在里面就隐含的调用了父类的无参的构造方法，如果父类中书写了自己的构造函数而忽略了无参构造函数，这是子类就不能自动调用无参构造函数，就会报错！！)，字super引用的是什么取决于是用它的类，我们可以访问父类成员，即使它们不是用于继承的，但是与this不一样的是，this引用的是一个类的某个特定实例，super是对父类成员的一个一般引用！

任何子类的构造方法的第一行必须是this(、、)/*这样同样能调用父类的构造方法！！而且父子类不会是所有的构造方法都是this(、、、)*/；或者super(、、)；的调用，如果程序员不写这些表达式，则系统会隐含的调用super(、、、)，当子类覆盖了父类的方法，如果要访问父类的方法(在子类中访问)就必须加spuer，但如果在第三方类中访问是不能实现的！！！！！

例子：

int i=0;

Leaf(int i){this.i=i;}就近原则！！

为什么所有的子类都要调用父类的构造方法？构造方法对象生成，因为在生成子类的时候就必须要构造方法

预定义引用：一个对象在创建时，系统会自动的生成一个对象自身的引用this，当内部类要访问外部类成员时，而恰好这个成员与内部类的成员同名时，就可以用this对这两个成员进行识别。格式：Outter.this.成员名

在子类中可以自己定义自己的独特的属性！如果子类的属性和父类的属性同名了(现实中小量存在，但是我们应该避免这样的情况的发生)，但是方法的同名却是很常见的！当同名的方法时，只要是不同的参数，就不会产生混淆；当同名同参的时候，这是调用子类的方法！

方法的覆盖(方法的重写?)1、发生在父类与子类之间。2、子类的方法与父类的方法同名又同参而且返回值是相同的！！3、子类的访问的控制不能比父类更封闭。4、子类抛出异常类型不能比父类更宽泛。子类和父类有相同的行为，但是方式是不一样的，例如动物是移动的，鸟是飞着的，鱼是游着的。

父类的非抽象方法可重写为抽象方法！！

方法的重载：方法名一样，参数列表不一样，(参数的个数、类型、顺序至少有一个不相同)，但是返回的类型和方法的类型可以不一样

可以使用final修饰符来定义一个方法，子类就不能重写final方法,这种用法确保某个派生类对某个方法是用的是某个特定定义！

一个类可以是一个或者多个其他类的父类，这就产生了类的层次结构！

所有java类都是直接或者间接派生自object类，通常我们会重写object类的例如：toString()，equals()方法来满足自己的需要

Instanceof :判断一个方法是不是一个类的实例！！

If(对象名instanceof类型名)

四、多态

意义1、如System.out.println();方法的重载简化了方法，这是多态的体现！

2、对象的多态，一种对象多种形态！决定于继承关系！这是最重要的多态！

A—B(A完全包含了B的范围时)。可以进行对象的多态A a=new B(” ”);

特征1、子类对象当作父类对象来体现时，就只能访问父类的已经定义的方法，不能访问子类自己独特的方法！！

2、如果子类覆盖了父类的方法，再把子类对象当作父类的对象来体现时，再去调用该方法时，调用的是子类覆盖后的方法！！对象的行为不会因为你当作什么就会改变！Animal a=new Bird();

主观认为客观存在

编译时的类型运行时的类型

3、如果父类对象当作子类的对象来体现时，需要强制转换(在前面添加子类的名)，但是也不是全部可以转换！！如：

Animal a=newFish();

Birdb=(Bird)a;//这样的强制转换是绝对不允许的，除非a是bird类型

注意编译器不会报错！但是在虚拟机上运行是会报错

常见异常：ClassCastException强制转换异常

NullPointException空指针异常

ArrayIndexOut Exception数组下标越界异常

4、静态方法和成员变量的绑定是静态绑定，实例方法的绑定是动态绑定！！！

Static：静态属性是描述类的特征，非静态属性描述各个对象的特征

静态和非静态的差别1：空间分配的时间不一样，静态属性是在类加载的时候分配的，实例属性(非静态属性)是在生成对象的时候分配的

2：空间分配的方式也不一样，静态属性只分配一个空间;实例属性则是有多少的对象就分配多少的空间哦！！

3：访问方式不一样，静态属性的访问是：类名.静态属性(与任何对象都没有关系)；而实例则是：对象.静态属性。

对于方法同样可以分为静态的方法(行为与某个对象无关)和非静态的方法(行为一定与某个对象有关)。访问时，静态方法的访问是：类名.对象方法(或者)对象.静态方法(不规范，存在奇异，最好别用)。

注意：在静态方法中，不能访问本类中非静态的成员

Java Test1.启动JVM2.找到Test.class3.加载Test.class4 .Test.main()；

静态代码块：类的加载和静态代码块执行顺序

静态方法没有多态，是不能够被覆盖的。与左边的对象没有关系，a.m1()；

Final：不变的最终的。可以修饰属性、方法、类、方法中的局部变量

修饰属性是，属性时不可以改变的；修饰方法表示方法不能被覆盖(但可以被重载！)；修饰类时表示类不能被继承；修饰方法中的局部变量时，同样是不可变的，相当于常量。

final属性赋值有两种方法：定义的时候赋值；或者在构造方法中进行赋值，任选其一！！

Final方法可以被重载，但不能被重写！！

1.static final int a=2;//静态final只能在定义的时候赋值，描述整个类的特征

2.final int b;//非静态final，一般是在构造方法中赋值！描述某一个个体

例：private static final int a=10;静态final表示一个类的

例：private final int b;表示一个对象的

Public FianlTest(int b){

This.b=b;

}

privateWeapon[ ]w;

Army(intn){

this.w=newWeapon[ n];

}

Abstract：抽象的，修饰类或者方法。

抽象类：不能实例化，但是具体类是可以实例化的。

如果一个类中包含有抽象方法，该类就必须定义成抽象类。

如果一个类不包含抽象方法，该类也可以定义成抽象类。(抽象类中可以有非抽象方法！！)

抽象类是可以实现接口的。

抽象类以具体类的最大差别时，抽象类不能生成对象，但是可以定义引用(可以引用得到子类的对象)

抽象类一般都是需要实现的，实现就是定义一个子类，覆盖(实现)父类的方法！！！

抽象类中Abstract与fianl时永远不能用在一起的。

抽象方法：不知道具体怎么实现就定义为抽象方法。

JVM实现机制

执行顺序：

先父类的静态代码块--子类的静态的静态代码块--所有的属性为0---父类的非静态代码块

---父类的属性付初始值--父类的构造函数--子类的属性付初始值--非静态代码块--子类的构造函数

建立多态的引用有两种方式：是用继承和使用接口。

一个引用变量可以指向创建字任何与其具有继承相关性的类的任一对象。

接口名字可以用来声名对象引用变量，接口引用可以指向任何实现该接口的任何类的任何对象。如Speaker current=new Philosopher()；请注意我们在使用接口的引用变量时，我们只能调用在该接口中定义的方法，即使它所指向的对象具有其可以响应的其他方法。但是我们可以通过强制转换来转换到恰当的引用中以使得它能够被编译器接受。如：

((Philosopher special).pontificate)();

接口：

1.接口中的所有方法都是抽象方法！

2.接口中的所有属性都是final static

3.接口也不能实例化，也可以定义接口引用(变量)

4．接口没有构造方法！

5.一个类只能继承一个类，但是接口可以多继承接口，接口是多态注入了新的活力！！

6.接口与接口之间可以多继承

接口相当于标准！把服务的使用者和服务的提供者分开，降低了系统的耦合，有效地提高了软件的可扩展性和可维护性！！现在软件工程所追求的是高内聚(与外界的联系很少)和低耦合(软件的模块和别的模块的关联越少，以后某个模块出现问题就能很好的修改)

java接口就是包含常量和抽象方法的集合，抽象方法就是不具有实现的方法。这就是说，没有为抽象方法定义的代码体。该方法的头，包括其参数列表，后面仅仅是一个分号。接口不能被实例化！！接口名字可以用来声名对象引用变量，接口引用可以指向任何实现该接口的任何类的任何对象。接口的缺省类型是public abstract，且他的实现类必须比它的缺省类型要低，比如可以是public类型！！1、声名接口2、实现接口3、使用接口

在实现多个接口的时候注意顺序，先继承在实现接口eg：class Sofa extends Chair implements Lie,Health,Care

抽象方法：及时在前面加上abstract，就算前面没有加，默认状态下，接口中的方法同样具有公共可见性(因为必须通过别的类来实例化)。一个类通过为定义咋接口中的方法提供方法来实现进而实现该接口，类在实现每个接口时，必须通过implements来实现，如果一个申明其来实现某个特定的接口，就必须为这个接口中的所有方法进行定义。任何一个没有没有被定义的方法，编译器都会报错！多个类可以实现同一接口，这就为这些方法提供了可选的方法.一个类可以实现多个接口,所以这个类就必须为所有列出的接口中的方法提供实现！！

Iterator接口：主要的方法是hasNext(返回一个boolean值)，next(返回一个对象)，这些方法都不带任何的参数。Next方法并不会把该对象从底层集合中删除，它仅仅是返回一个指向它的引用。Iterator接口有一个remove方法，它不带参数且具有一个void返回类型，调用此方法就会从底层集合中删除next方法最近返回的值！

接口知识点补充：

接口重要作用：1)强制2)解耦3)过滤

接口遵循类的类型赋值兼并原则，即实现类可被看做接口类型。

Class Client{

Public void printClient(Print s)/*接口为参数类型*/

s.printChar()；

}

、、、、、、main{

New Client.printClient(new Server())；

}

优点：对于客户类中的pribtClient()方法来说，只要接口Print不变，实现类Server代码怎么变化都不会影响客户代码，这样服务方在对服务进行升级时连服务类名改变了，只需在主类中稍微加以修改。

抽象类：抽象类代表类层次结构中的一个宽泛的概念。抽象类不能被实例化，且通过含有一个或多个没有定义的抽象方法，。从这个意义上说，抽象类和接口类似。但是，与接口不一样的是，抽象类可以包含非抽象的方法，以及可以包含除了常量以外的数据声名，并且任何抽象类必须包含有abstract修饰符！！声名为abstract的类不一定要包含抽象的方法！而是任何含有抽象方法的类必须声明为abstract。

抽象类同样和接口一样可以作为方法参数。

继承的概念适用于类也适用于接口，这就是说一个接口可以由另外的一个借口继承而来，这些关系就构成了接口的层次结构，它与类的层次结构类似。 当父类接口派生出一个子接口时，该子接口就集成了父类的所有的抽象方法和常量，任何实现子接口的类必须实现其所有的方法，对于接口之间的继承不存在任何的限制，(没有类中的保护和私有成员具有的那些限制)，应为接口所有成员都是公共的。

泛型：java中我们可以将一个类定义为泛型，这就是说我们可以定义一个类来存储，操作和管理这样的对象，即对象的类型知道该类实例化后才得到指定。Class Box{//声名以及管理T型对象的代码}

其内部存储的是对object类的引用，然后任何类型和对象都可以存储在Box里面，事实上里面可以存储对个彼此无关的对象类型，在达到这种水平的代码的灵活性的同时，我们却失去了很多的可控性！

问题一：抽象类中有构造方法没？有

二：抽象类能够继承？派生出来的都是抽象类？抽象类派生出不一定都是抽象类，且必须实现父类的抽象方法，抽象类里面可以包含非抽象方法来实现！！

三：静态属性什么时候被加载？

修饰符应用汇总：

staticfinalabstractpublicprotecteddefaultprivate

顶层类：noyesyesyesnoyesno

属性： yesyesnoyesyesyesyes

方法： yesyesyesyesyesyesyes

局部：noyesnonononono

成员式内部类：yesyesyesyesyesyesyes

局部式内部类：noyesyesnononono

接口：nonoyesyesnonono

Default最多只能在包中进行访问

Java.lang.Object十一个方法汇总：

①：clone();分为浅拷贝和深拷贝

例：Student name;

Student teacher;

int age;

0x2201name浅拷贝！！

s1 0x123420age

0x2234teacher

0x2201namezhangsan(学生)深拷贝！！

s2 0x123420age20(学生)

0x2234teacherlilaoshi(老师)

要实现这个方法就必须实现下面两个方法：

1、这个类必须实现Cloneable(标记接口)

2、覆盖Object中的clone();

②：equlse();源代码：public boolean equals(Object obj) {

return (this = = obj);

}

和= =作用一样，在实际开发上没有实际意义，而只是抽象对象的需要，我们需要做的就是在进行覆盖这个方法！！

equlse一般是比较对象的值是否相等，而= =一般是比较对象的引用地址相等不

③：finalize();

源代码：protected void finalize() throws Throwable { }

④：toString();返回字符串

源代码：public String toString() {

return getClass().getName() + "@" + Integer.toHexString(hashCode());

}

直接输出对象都要自动调用系统默认的toString()，但是我们可以自己进行覆盖！！