java多态的好处和弊端
【Java】面向对象的四个基本特征：唯一性、分类性、继承性和多态性
【Java】⾯向对象的四个基本特征：唯⼀性、分类性、继承性
和多态性
1.唯⼀性
唯⼀性是指每个对象都是唯⼀的，具有唯⼀标识符。
在对象的整个⽣命周期中，标识符是⼀成不变的，系统可通过该标识符，在内存中找到相应对象。
2.分类性
分类性是指将具有⼀致属性和⾏为的对象抽象成类，只保留与应⽤有关的性质，其他内容忽略。
任何类的划分都是主观的，但必须与具体应⽤有关。
3.继承性
继承性是指⼦类⾃动继承⽗类的属性和⽅法，并且可以在⽗类的基础上加⼊若⼲新内容。
例如，“⼈”这个类抽象了这个群体的基本特征，⽽“学⽣”和“⽼师”除了具备“⼈”所定义的基础特性外，各⾃⼜具有各⾃的新特性。
继承性是⾯向对象程序设计语⾔不同于其他语⾔的最重要特点。
通过类的继承，可使公共的特性能够共享，提⾼代码的可重⽤性、减少冗余，同时简化了对象、类的创建⼯作，规范了类的等级结构。
4.多态性
多态性是指不同对象，在收到同⼀消息后，可产⽣不同结果，具有不同表现⾏为。
多态性允许每个对象以⾃⾝的⽅法去响应共同消息，以此增强软件的灵活性和可重⽤性。
多态的概念和作用（深入理解）
多态的概念和作⽤（深⼊理解）多态是⾯向对象的重要特性,简单点说:“⼀个接⼝，多种实现”，就是同⼀种事物表现出的多种形态。
编程其实就是⼀个将具体世界进⾏抽象化的过程，多态就是抽象化的⼀种体现，把⼀系列具体事物的共同点抽象出来, 再通过这个抽象的事物, 与不同的具体事物进⾏对话。
对不同类的对象发出相同的消息将会有不同的⾏为。
⽐如，你的⽼板让所有员⼯在九点钟开始⼯作, 他只要在九点钟的时候说：“开始⼯作”即可，⽽不需要对销售⼈员说：“开始销售⼯作”，对技术⼈员说：“开始技术⼯作”, 因为“员⼯”是⼀个抽象的事物, 只要是员⼯就可以开始⼯作，他知道这⼀点就⾏了。
⾄于每个员⼯，当然会各司其职，做各⾃的⼯作。
多态允许将⼦类的对象当作⽗类的对象使⽤，某⽗类型的引⽤指向其⼦类型的对象,调⽤的⽅法是该⼦类型的⽅法。
这⾥引⽤和调⽤⽅法的代码编译前就已经决定了,⽽引⽤所指向的对象可以在运⾏期间动态绑定。
再举个⽐较形象的例⼦：⽐如有⼀个函数是叫某个⼈来吃饭，函数要求传递的参数是⼈的对象，可是来了⼀个美国⼈，你看到的可能是⽤⼑和叉⼦在吃饭，⽽来了⼀个中国⼈你看到的可能是⽤筷⼦在吃饭，这就体现出了同样是⼀个⽅法，可以却产⽣了不同的形态，这就是多态！多态的作⽤：1. 应⽤程序不必为每⼀个派⽣类编写功能调⽤，只需要对抽象基类进⾏处理即可。
⼤⼤提⾼程序的可复⽤性。
//继承2. 派⽣类的功能可以被基类的⽅法或引⽤变量所调⽤，这叫向后兼容，可以提⾼可扩充性和可维护性。
//多态的真正作⽤，以前需要⽤switch实现----------------------------------------------------多态是⾯向对象程序设计和⾯向过程程序设计的主要区别之⼀，何谓多态？记得在CSDN⾥⼀篇论C++多态的⽂章⾥有⼀名话：“龙⽣九⼦，⼦⼦不同”多态就是同⼀个处理⼿段可以⽤来处理多种不同的情况，在钱能⽼师的《C++程序设计教程》书中有这样⼀个例⼦：定义了⼀个⼩学⽣类[本⽂全部代码均⽤伪码]class Student{public:Student(){}~Student(){}void 交学费(){}//......};⾥⾯有⼀个 “交学费”的处理函数，因为⼤学⽣和⼩学⽣⼀些情况类似，我们从⼩学⽣类中派⽣出⼤学⽣类：class AcadStudent:public Student{public:AcadStudent(){}~ AcadStudent(){}void 交学费(){}//.......};我们知道，中学⽣交费和⼤学⽣交费情况是不同的，所以虽然我们在⼤学⽣中继承了中学⽣的"交学费"操作，但我们不⽤，把它重载，定义⼤学⽣⾃⼰的交学费操作，这样当我们定义了⼀个⼩学⽣，⼀个⼤学⽣后：Student A;AcadStudent B;A.交学费(); 即调⽤⼩学⽣的，B.交学费();是调⽤⼤学⽣的，功能是实现了，但是你要意识到，可能情况不仅这两种，可能N种如：⼩学⽣、初中⽣、⾼中⽣、研究⽣.....它们都可以以Student[⼩学⽣类]为基类。
java面向对象的四个特性
java⾯向对象的四个特性java⾯向对象编程是指：Java语⾔提供类、接⼝和继承等⾯向对象的特性，为了简单起见，只⽀持类之间的单继承，但⽀持接⼝之间的多继承，并⽀持类与接⼝之间的实现机制（关键字为implements）。
另外，java是⾯向对象，但不是所有的都是对象，基本数据类型就不是对象，所以才会有封装类。
⾯向对象的特性有1）抽象，2）封装，3）继承，4）多态。
1）抽象 抽象类：包含抽象⽅法的类称之为抽象类，但不意味着抽象类中只能有抽象⽅法，它和普通类⼀样，可以拥有普通的成员变量、⽅法。
1、抽象类不能被实例化。
抽象类的⼦类必须给出抽象类中的抽象⽅法的具体实现，除⾮该⼦类也是抽象类。
2、抽象类中不⼀定包含抽象⽅法，但是有抽象⽅法的类必定是抽象类。
3、抽象类中的抽象⽅法只是声明，不包含⽅法体，就是不给出⽅法的具体实现也就是⽅法的具体功能。
4、构造⽅法，类⽅法（⽤ static 修饰的⽅法）不能声明为抽象⽅法。
5、被定义为abstract的类需要被⼦类继承，但是被修饰为final的类是不能被继承和改写的，这两者是不能⼀起⽤来做修饰的。
接⼝：接⼝是⼀种特殊的抽象类。
当使⽤类的时候，仅关注其⾏为，不关⼼继承时可以使⽤接⼝来代替类。
接⼝中的⽅法都是抽象⽅法，abstract默认不写，所以抽象类中的抽象⽅法不能⽤访问修饰符。
接⼝中声明的成员默认为static final成员（不管是基础数据类型还是引⽤类型），且必须初始化。
接⼝的特性： 1、接⼝中每⼀个⽅法也是隐式抽象的,接⼝中的⽅法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。
2、接⼝中可以含有变量，但是接⼝中的变量会被隐式的指定为 public static final 变量（并且只能是 public，⽤ private 修饰会报编译错误）。
3、接⼝中的⽅法是不能在接⼝中实现的，只能由实现接⼝的类来实现接⼝中的⽅法。
一 如何使用Jav1
一如何使用Java 【JavaOOP】1.封装封装就是将属性私有化，提供公有的方法访问私有属性。
2.this关键字This是对象内部指代自身的引用，this可以直接引用对象，可以用它来解决实例变量和局部变量之间发生的任何同名冲突。
3.构造方法方法名与类名相同没有返回类型4.方法重载构造方法是一种典型的方法重载的例子Java中，两个方法名称相同，但参数不相同5.封装的优点：实现对属性的数据访问限制增强程序的可维护性6.继承extends关键字来继承子类自动继承父类的属性和方法子类构造方法中，通过super关键字调用父类的构造方法子类中重写了父类的方法，通过super关键字调用父类的方法创建对象时，先创建父类对象再创建子类对象。
没有显示调用父类的注：调用父类的构造方法语句（super语句）必须是构造方法中第一条语句继承的优点：实现代码的复用度7.多态具有表现多种形态的能力的特征多态的优点：提高代码的可扩展性和可维护性8.多态的条件：要在继承的关系下子类需要父类的方法父类的引用指向子类8.方法重写（override））用@override测试下面方法是否能被重写子类中的方法，方法名称，参数列表，返回类型相同【完全相同啦[除了方法体]】面向对象的三大特性：封装：提高代码的安全性和可维护性，增加属性的访问限制继承：提高代码的复用度多态：提高代码的可扩展性和可维护性代码块静态代码块/语句块构造代码块{}静态代码块static{}静态变量、方法、代码块。
只要是static修饰的一些在类加载的时候就被加载了。
其他一些普通的就是在创建对象的时候在执行的9. 接口：必须建立在多态的基础上，否则毫无意义【接口是一套规范】接口不能被实例化接口中的成员自动设置为public，不能声明私有成员接口中不能有方法体实现接口，就必须实现其中定义的所有方法接口的优点：提高代码的复用度，增加城乡的可维护性，可扩展性10：常量常量是一种标示符，它的值在运行期间恒定不变常量不属于任何对象，必须用static final 修饰只能被引用，不能被赋值注：用final修饰的类，这个类不能被继承11.异常程序在运行过程中所发生的不正常的事件，从而中断了正在运行的程序12.throw throwsThrow 用来抛出异常Throws 用来声明某个方法可能会抛出各种异常。
java总结
1、Servlet与JSP有什么区别？Servlet和JSP完成的功能是相同的，都可以接收用户的请求，可以对用户进行响应，可以调用业务方法。
不同点在于JSP是在html或者xml中嵌入了Java代码或者JSP的标记，在制作页面方面具有优势，可以使用网页编辑工具来制作网页，然后嵌入Java或者JSP的标记。
Servlet是纯Java代码，通常用于控制，不用于输出。
在MVC模式中，JSP通常充当视图，Servlet通常充当控制器。
另外，JSP 在运行的时候还要转换成类似于Servlet的Java代码。
2、Servelt通常有哪些方法init方法，完成初始化service方法，包括doGet和doPost，用于接收用户的请求，调用后台的JavaBean或者EJB，选择界面对用户响应。
destroy方法，用于释放资源3、谈谈Servlet的生命周期当接收到请求的时候，容器察看对应的Servlet对象是否存在，如果不存在，需要加载Servetl，实例化Servlet，调用init方法进行初始化。
如果已经存在，根据用户的请求创建request和response对象，把这两个对象作为参数调用Servlet对象的service方法，Servlet通过这个方法与用户进行交互，方法执行完之后，对请求的处理结束。
Servelt对象继续等待下一个请求。
当应用卸载的时候，调用destroy 方法释放资源。
多个请求共享Servelt对象。
4、Servlet API的两个主要包javax.servlet.*;javax.servlet.http.*;5、编写Servlet需要继承的类是什么？HttpServlet6、编写Servlet通常需要实现的两个方法是什么？doGet方法和doPost方法7、doGet方法和doPost方法中的两个参数是什么？HttpServletRequest和HttpServletResponse，前者封装了与请求相关的信息，后者封装了与响应相关的信息。
黑马点招面试问题
1.静态变量和实例变量的区别局部变量不能用静态的，如果用了静态的，则不会从静态区消失* 静态变量也叫类变量成员变量也叫对象变量* A:所属不同* 静态变量属于类，所以也称为为类变量* 成员变量属于对象，所以也称为实例变量(对象变量)* B:内存中位置不同* 静态变量存储于方法区的静态区* 成员变量存储于堆内存* C:内存出现时间不同* 静态变量随着类的加载而加载，随着类的消失而消失* 成员变量随着对象的创建而存在，随着对象的消失而消失* D:调用不同* 静态变量可以通过类名调用，也可以通过对象调用* 成员变量只能通过对象名调用2.Interger和int的区别int是java提供的8种原始数据类型之一。
Java为每个原始类型提供了封装类，Integer 是java为int提供的封装类。
int的默认值为0，而Integer的默认值为null，即Integer可以区分出未赋值和值为0的区别，int则无法表达出未赋值的情况，另外，Integer提供了多个与整数相关的操作方法，例如，将一个字符串转换成整数，Integer中还定义了表示整数的最大值和最小值的常量。
3.谈谈你对面向对象的理解如何大象装进冰箱？面向过程：为了把大象装进冰箱，需要3个过程。
1) 把冰箱门打开（得到打开门的冰箱）2) 把大象装进去（打开门后，得到里面装着大象的冰箱）3) 把冰箱门关上（打开门、装好大象后，获得关好门的冰箱）每个过程有一个阶段性的目标，依次完成这些过程，就能把大象装进冰箱。
1:冰箱开门(冰箱)冰箱装进(冰箱, 大象)冰箱关门(冰箱)==换个写法(冰箱开门冰箱)(冰箱装进冰箱大象)(冰箱关门冰箱)2:冰箱关门(冰箱装进(冰箱开门(冰箱), 大象))==换个写法(冰箱关门 (冰箱装进 (冰箱开门冰箱) 大象))面向对象：每个动作有一个执行者，它就是对象。
1) 冰箱，你给我把门打开2) 冰箱，你给我把大象装进去（或者说，大象，你给我钻到冰箱里去）3) 冰箱，你给我把门关上依次做这些动作，就能把大象装进冰箱。
JAVA的三大特性
JAVA的三⼤特性众所周知，java的三⼤特性为：封装，继承和多态。
⼀、封装1. 封装就是将类的信息隐藏在类内部，不允许外部程序直接访问，⽽是通过该类的⽅法实现对隐藏信息的操作和访问。
2. 封装是怎么实现的呢？a. 需要修改属性的访问控制符（修改为private）；b. 创建getter/setter⽅法（⽤于属性的读写）；c. 在getter/setter⽅法中加⼊属性控制语句（⽤于判断属性值的合法性）;public class Student {private String id;private int score;public String getId() {return id;}public void setId(String id) {this.id = id;}public int getScore() {return score;}public void setScore(int score) {this.score = score;}}封装不是简单地将类的属性进⾏封装，还可以对⽅法进⾏封装。
说道这⾥，我就⼀直很奇怪为什么要封装，封装的好处是什么。
⾄于为什么需要封装，因为⾯向对象中所有的实体都是以对象为基本单位的，以宏观世界的实体来映射到计算机世界中，每个对象有它⾃⼰的属性和⾃⼰的⾏为，我们⽤类来将这些属性和⾏为封装到⼀起，当它实例化出来⼀个对象的时候，我们可以说这个对象具有这些属性和⾏为。
不同类别的对象正是因为这些特性的不同，我们才可以将它们区分开，⽽这也正反映了我们现实⽣活中不同种类个体的不同。
举个例⼦，⽐如现在有⼀个Int类型的数据a，它的初始值为0，通过这个变量可以表达出学⽣的考试成绩。
但是仅仅只能表达出学⽣的成绩为0分，不能表达出学⽣缺考的情况。
但是如果我们现在成绩的类型变为Integer ，那么就不⼀样了，现在有⼀个Integer类型的数据b，它的初始值为null，通过null和0我们就能区分出来学⽣是0分还是缺考的两种不同状态。
重载和多态的区别
重载和多态的区别多态性也是面向对象方法的一个重要特性.多态性是指在在程序中出现的"重名"现象,即在一个程序中相同的名字可以表示不同的实现.在JAVA中,多态性主要表现在如下两个方面:1方法重载.通常指在同一个类中,相同的方法名对应着不同的方法实现,但是方法的参数不同.2成员覆盖.通常指在不同类父类和子类中,允许有相同的变量名,但是数据类型不同;也允许有相同的方法名，但是对应的方法实现不同.在重载的情况下,同一类中具有相同的名字的方法.如何选择它的方法体呢?不能使用类名来区分,通常采用不同的方法形参表,区分重载要求形参在类型,个数和顺序的不同,在定义重载方法时,应在方法的形参的类型,个数和顺序有所不同,以便在选择时能够区别开来.在覆盖的情况下,同名的方法存在于不同的类中,在调用方法只要指明其方法所归属的类名就可以了.例如class Shape {void draw {}void erase {}}class Circle extends Shape {void draw {System.out.println"Circle.draw";}void erase {System.out.println"Circle.erase"; }}class Square extends Shape {void draw {System.out.println"Square.draw";}void erase {System.out.println"Square.erase";}}class Triangle extends Shape {void draw {System.out.println"Triangle.draw";}void erase {System.out.println"Triangle.erase";}}public class Test {public static Shape randShape {switchintMath.random * 3 {default:case 0: return new Circle;case 1: return new Square;case 2: return new Triangle;} }public static void mainString[] args {Shape[] s = new Shape[9];forint i = 0; i < s.length; i++ s[i] = randShape;forint i = 0; i < s.length; i++ s[i].draw;}}输出结果Triangle.drawCircle.drawTriangle.drawTriangle.drawTriangle.drawSquare.drawSquare.drawTriangle.drawCircle.drawTriangle.eraseCircle.eraseTriangle.eraseTriangle.eraseTriangle.eraseSquare.eraseSquare.eraseTriangle.eraseCircle.erasePress any key to continue...又一次执行Triangle.drawTriangle.drawCircle.drawCircle.drawCircle.drawTriangle.drawTriangle.drawSquare.drawCircle.drawTriangle.eraseTriangle.eraseCircle.eraseCircle.eraseCircle.eraseTriangle.eraseTriangle.eraseSquare.eraseCircle.erasePress any key to continue...两次执行结果不同的原因是其中的Math.random这个类导致的,math.random得到的数是0-1之间的随机数.写到这里,我突然想到了方法重载,那么它和多态,覆盖有什么区别呢?到GOOGLE是搜素了一下，不少.不过，最重要的一点区别是:通过方法重载进而实现对象的多态性.方法重载是指功能相同的多个方法使用同一个方法名.同名的多个方法的参数要有所不同,即在参数类型,参数个数和参数顺序上要有所区别,以便作为选择某个方法的根据.通常只有功能相同的方法进行重载才有意义.例如:计算两个数之和的重载方法定义如下:int addint i,int j{retrun i+j;}float addfloat i,float j{retrun i+j;}double adddouble i,double j{retrun i+j;}重载方法的选择通常是在编译时进行.系统根据不同的参数类型,个数或顺序,寻找最佳匹配方法.方法类型不参与匹配.下面是搜到的一些例子.public class Base{int a,b;public Baseint x,int y{a = x;b = y;}public int add{return a + b;}public void addint x,int y{int z;z = x + y;}}上面这段代码就是重载~~~他有三个特征1：方法名必须一样“add“。
继承多态封装的意义
继承多态封装的意义继承、多态和封装是面向对象编程中的三大特性。
它们是面向对象编程的核心，也是程序员必须掌握的基础知识。
在本文中，我们将重点讨论继承、多态和封装的意义以及它们在面向对象编程中的作用。
一、继承的意义继承是面向对象编程中的一种重要的机制，它允许一个类从另一个类中继承属性和方法。
继承的意义在于：1、减少重复代码继承可以减少代码的重复。
当多个类有相同的属性和方法时，我们可以把这些属性和方法放在一个父类中，子类可以继承这些属性和方法，从而避免了重复编写代码的麻烦。
2、提高代码的可维护性继承可以提高代码的可维护性。
当需要修改某个属性或方法时，只需要在父类中修改一次，所有继承自父类的子类都会自动更新。
3、增强代码的扩展性继承可以增强代码的扩展性。
当需要增加新的属性或方法时，只需要在父类中添加即可，所有继承自父类的子类都可以使用这些新的属性和方法。
二、多态的意义多态是面向对象编程中的一个重要概念，它允许不同的对象对同一消息做出不同的响应。
多态的意义在于：1、提高代码的灵活性多态可以提高代码的灵活性。
当需要处理一组不同的对象时，可以采用多态的方式，使得代码更加灵活。
2、增强代码的可扩展性多态可以增强代码的可扩展性。
当需要增加新的对象时，只需要实现相应的接口或继承相应的类即可，不需要修改原有的代码。
3、提高代码的可读性多态可以提高代码的可读性。
通过多态的方式，可以使代码更加简洁、清晰，易于理解。
三、封装的意义封装是面向对象编程中的一个重要概念，它可以将数据和方法隐藏在类的内部，仅对外部提供接口。
封装的意义在于：1、提高代码的安全性封装可以提高代码的安全性。
将数据和方法隐藏在类的内部，可以防止外部直接访问和修改数据，从而保证数据的安全性。
2、提高代码的可维护性封装可以提高代码的可维护性。
类的内部数据和方法只对外部提供接口，当需要修改数据或方法时，只需要修改接口而不需要修改调用接口的代码。
3、提高代码的可读性封装可以提高代码的可读性。
《java面向对象程序设计继承和多态》教案
《Java面向对象程序设计-继承和多态》教案第一章：引言1.1 课程简介本课程旨在帮助学生掌握Java面向对象程序设计中的继承和多态概念。
通过学习，学生将能够理解继承和多态的原理，并能够运用它们解决实际编程问题。
1.2 课程目标理解继承的概念和原理掌握如何使用继承来实现代码复用理解多态的概念和原理掌握如何使用多态来实现动态绑定第二章：继承2.1 继承的概念介绍继承的定义和作用解释为什么使用继承2.2 继承的语法介绍如何使用extends关键字实现继承解释继承中的构造函数和继承关系2.3 继承的实现演示如何使用继承来复用代码解释继承的层次结构和菱形继承第三章：多态3.1 多态的概念介绍多态的定义和作用解释多态的好处3.2 方法重写解释方法重写的概念和规则演示如何使用方法重写来实现多态3.3 方法重载解释方法重载的概念和规则演示如何使用方法重载来提高代码可读性第四章：继承和多态的案例分析4.1 案例一：动物和鸟类使用继承和多态来定义动物和鸟类的关系实现动物和鸟类的属性和方法4.2 案例二：形状和圆形使用继承和多态来定义形状和圆形的关系实现形状和圆形的属性和方法第五章：总结和练习5.1 课程总结回顾继承和多态的概念和原理强调继承和多态在面向对象程序设计中的重要性5.2 练习题提供一些练习题，以帮助学生巩固所学知识第六章：继承和多态的深入理解6.1 继承的类型解释接口继承和类继承的区别讨论继承的优点和缺点6.2 多态的应用探讨多态在日常编程中的应用场景分析多态如何提高程序的可扩展性和灵活性第七章：Java中的继承和多态实例7.1 继承实例：汽车和摩托车通过实例展示如何使用继承来创建汽车和摩托车类演示如何通过继承来扩展属性和方法7.2 多态实例：支付接口和具体的支付方式创建一个支付接口和多个具体的支付方式类演示如何使用多态来实现不同的支付方法第八章：继承和多态的陷阱与最佳实践8.1 继承的陷阱讨论继承可能带来的过度耦合问题解释如何避免继承的陷阱8.2 多态的陷阱分析多态可能导致的类型不匹配问题探讨如何安全地使用多态8.3 最佳实践提供使用继承和多态的最佳实践指南强调代码可读性和可维护性第九章：继承和多态在设计模式中的应用9.1 设计模式简介介绍设计模式的概念和重要性解释设计模式与继承和多态的关系9.2 继承和多态在设计模式中的应用案例通过案例分析展示继承和多态如何在设计模式中发挥作用讨论设计模式如何提高程序设计的质量和可复用性第十章：课程回顾与拓展学习10.1 课程回顾总结本课程的重点内容和关键概念强调继承和多态在实际编程中的应用10.2 拓展学习资源提供一些拓展学习的资源和建议鼓励学生继续深入学习面向对象程序设计的其他方面第十一章：继承和多态的实际应用案例11.1 案例分析：图形库的设计通过分析图形库的设计，展示继承和多态如何用于实现复杂的图形操作。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
多态的好处：
1.提高了代码的维护性（继承保证）
2.提高了代码的扩展性（由多态保证）
多态的弊端：
1.不能使用子类的特有功能
2.创建子类对象调用方法（可行但是很多时候是不合理的，而且太占内存）
3.
对象间的转型问题
1.向上转型（父类引用指向子类对象）
Fu f=new zi();现在是zi类型的，外面看到的是fu类型的所以是zi向fu的向上转型
2.向下转型（父类引用转为子类对象）
Zi z=（zi）f；看到的是f，外面看到的是zi所以是f向zi的向下转型
多态的成员访问特点：
成员变量：编译看左边，运行看左边
成员方法：编译看左边，运行看右边
构造方法：创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化。
静态方法：编译看左边，运行看左边
成员方法存在方法的重写，所以运行看右边
继承的时候：
子类中有和父类中一样的方法，叫重写
子类中没有父类中出现过的方法，方法被继承过来了。
抽象类的概述
特点：抽象类和抽象方法必须用abstract关键字修饰
抽象类的实例化是靠具体的子类进行实例化 的
接口的特点：
接口不能实例化，以多态的方式实例化
成员变量：只能是常量，而且是静态的
1.Public int num=10;
2.Public final int num2=20;
3.Public static final i nt num3=30;
注：如果写成第一种方式的，那么它就是省略了第三种里面的static和final
接口中的变量默认是常量
接口没有构造方法，因为接口主要是扩展功能的，而没有具体存在
成员方法：
只能是抽象方法
默认修饰符public abstract
类与类 ，类与接口，接口与接口的关系
类与类继承关系，只能单继承，可以多层继承
类与接口实现关系
接口与接口：可以多继承，单继承
抽象类和接口之间的区别
抽象类：
1.成员区别：a,成员变量：可以是变量
2.构造方法：有
3.成员方法：可以抽象，也可以非抽象
接口：
1.成员变量：只可以常量
2.长远方法：只可以抽象；
设计理念区别
抽象类 被继承体现的是： is a的关系。抽象类中定义的是噶继承体系的共性功能
接口 被实现体现的是 like a的关系。接口中定义的是该继承体系的扩展功能。