package mianxiangduixiangtest;public class DongTaiJingTaitest {public static void main(String[] args) {Animal animal = new Cat();animal.drink();animal.eat();//猫喝水//动物吃饭//即eat方法是与类静态绑定的，在JVM类加载时就确定animal调用的是Animal的eat方法，不需要创建对象//drink方法是与对象动态绑定的，即在运行时才确定drink方法调用的是Cat中的drink方法}
}class Animal{static void eat(){System.out.println("动物吃饭");}void drink(){System.out.println("动物喝水");}
}
class Cat extends Animal{static void eat(){System.out.println("猫吃饭");}void drink(){System.out.println("猫喝水");}
}

④理解多态

从编译+运行角度
– 编译时，java规定类只能调用自己结构中定义的方法，且规定父类引用可以指向子类的实例（只看语法）
– 运行时，由于类加载顺序或初始化顺序，子类重写的方法覆盖了父类的原方法，故实际上父类引用调用的方法为子类重写的方法（只看引用指向的类加载的结构）
从反射的角度
– 事实上，父类的引用可以调用子类个性的方法，只不过只能在运行期间实现，因为编译时会报错（必须调用自己结构中定义的方法）。
– 由此可以解释父类引用指向子类对象时，在运行期间，父类引用等同于子类引用，可以调用子类所有的方法和属性

⑤多态代码实现

package mianxiangduixiangtest;import java.lang.reflect.Method;public class DuoTaiTest {public static void main(String[] args) throws Exception {People p = new Man();//p.eat()过编译，运行时p实际上指向的是子类的结构，故p可以调用子类的方法//输出男人吃饭p.eat();// p.drink(); 不过编译，因为编译只能运行引用类型 类的结构Class aClass = p.getClass();Method drink = aClass.getDeclaredMethod("drink");//输出男人喝水drink.invoke(p);}
}
class People{void eat(){System.out.println("人吃饭");}
}
class Man extends People{void eat(){System.out.println("男人吃饭");}void drink(){System.out.println("男人喝水");}
}

3.接口与抽象类的相同点和不同点？

接口方法完全抽象，implements，无构造器，默认public也只能是，
子类实现接口必须重写。
抽象类可以有默认实现，extends，有构造器，所有封装都可，
子类继承抽象类不重写成为抽象类。
两者都无法实例化，都可以作为多态的引用
代码

package mianxiangduixiangtest;public class ChouJieTest {
}interface Cup{void Size();
}
abstract class Cup1{//接口可以有默认实现static void Size1(){System.out.println("大尺寸");}abstract void Size();
}

4.equals和toString的判断？

Object类的equals底层判断 ==
实现的类需要重写equals和toString

5.新建对象的流程是什么？new一个对象的流程？

①类加载

类加载到方法区中（原因：方便JVM找.class文件）

②开辟内存空间

开辟堆内存空间（原因：寻找对象需要的内存空间）

③初始化成员变量

初始化父类静态变量或静态代码块
初始化子类静态变量或静态代码块
父类普通变量-初始化代码块-构造方法
子类普通便利-初始化代码块-构造方法

④引用变量建立连接

6.深拷贝浅拷贝和引用拷贝的区别？

①三者概念

深拷贝：堆中创建新对象，类中的引用类型也是创建新对象
浅拷贝：堆中创建新对象，类中的引用类型复制引用地址
引用拷贝：两个引用指向同一堆对象

②拷贝实现

Object类中的clone方法
– 能够复制一个新的对象在堆内存中(super.clone),复制结果为Object,需要进行类型强转
– native方法非java实现，是protected类型的
Cloneable接口
– 标记接口
–只有实现这个接口后，然后在类中重写Object中的clone方法，然后通过类调用clone方法才能克隆成功,调用中JVM底层方法判断类是否有标记接口Cloneable，有则克隆成功。
深拷贝与浅拷贝实现
– 深拷贝自己和每个成员属性都实现Cloneable接口并重写clone
– 浅拷贝自己实现Cloneable接口重写clone即可

③代码实战

package mianxiangduixiangtest;public class ShengQianCopyTest {public static void main(String[] args) throws Exception{Paper paper = new Paper();Paper clone = (Paper)paper.clone();System.out.println(paper == clone);System.out.println(paper.tree==clone.tree);//浅复制时，第一个结果false,第二个结果为true,说明确实赋复制了新对象,但是对象内部的引用属性为赋值Paper1 paper1 = new Paper1();Paper1 clone1 = paper1.clone();System.out.println(paper1 == clone1);System.out.println(paper1.tree1==clone1.tree1);//深复制时,第一个结果和第二个结果都为false,说明确实复制了新对象，并且对象内部的对象属性也被赋值}
}class Paper implements Cloneable{Tree tree;@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();}
}
class Tree{}
class Paper1 implements Cloneable{Tree1 tree1 = new Tree1();@Overrideprotected Paper1 clone() throws CloneNotSupportedException {Paper1 paper1 = (Paper1)super.clone();paper1.tree1 = (Tree1) this.tree1.clone();return paper1;}
}
class Tree1 implements Cloneable{@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();}
}

7.类的多种类型？

①同级类

.java文件中有多个同级类（编译后多个.class文件）
public只能修饰其中一个

②内部类

即分为局部内部类和成员内部类
– 局部内部类定义在代码块和方法中
– 成员内部类定义在类中，成员内部类分为非静态成员内部类和静态成员内部类，其中还有匿名内部类（只能使用一次）。
非静态成员内部类：无法脱离外部类实例来实例化（成员属性）
静态内部类：
– 访问静态外部成员
– 实例化不依赖于外部类，实例化外部对象可以访问外部非静态结构
匿名内部类：是某个类的子类
局部内部类：方法或代码块中

③代码示例

package mianxiangduixiangtest;public class NeiBuLeiTest {public static void main(String[] args) {//静态内部类可以通过外部类.内部类来实例化Person.Inner1 inner1 = new Person.Inner1();//成员内部类必须通过外部类的实例化来实例化Person person = new Person();Person.Inner inner = person.new Inner();}
}class Person{//成员内部类class Inner{}//静态内部类static class Inner1{}//匿名内部类Dog dog = new Dog(){};//局部内部类{class Cat{}}}
class Dog{}