《跨平台程序设计语言》课件-第 4 章 类的封装性、继承性、多态性及接口

第4章类的封装性、继承性、多态性及接口1.封装字段什么是封装封装：封装又称为信息隐藏。是指利用抽象数据类型将数据的操作结合在一起，使其构成一个不可分割的独立实体，尽可能隐藏内部的细节，只保留一些对外接口（可以理解为公开的方法和属性），使其与外部发生联系。比如手机，手机的键盘，屏幕，听筒等，就是其对外接口。你只需要知道如何按键就可以使用手机，而不需要了解手机内部的电路是如何工作的。封装机制就像手机一样只将对外接口暴露，而不需要用户去了解其内部实现。什么是封装字段封装字段：之前的操作中可发现所有类中的成员属性都是直接通过实例化对象在类的外部调用。这样是不安全的。最稳妥的就是利用private实现成员属性的封装处理。而一旦使用了private封装之后，是不允许外部对象进行调用的，如果属性需要被外部所使用，那么按照要求，定义属性相应的setter和getter方法。实现封装字段以Person类中的intage为例：setter方法是设置属性内容；getter方法是取得属性内容；publicclassPerson{...... privateintage; //私有化年龄字段......}publicvoidsetAge(intage){this.age=age; //设置字段值，注意：无返回值，有参数（参数的数据类型）}publicintgetAge(){returnthis.age; //获得字段值，注意：有返回值（返回值的数据类型），无参数。}封装字段练习设计一个名为Person的类表示人来，这个类包括：一个名为name的String型的private成员变量；一个名为age的int型的private成员变量；一个名为info()的public方法实现在控制台打印信息（格式为：我叫{name}，我的年龄是{age}），返回值为void型。创建人类的无参构造函数。创建name和age为指定值的有参构造函数。封装name和age，增加属性的getter和setter方法。编写一个测试程序，创建两个Person对象：一个人类的name=小A，age=30，另一个人类的name=小红，age=18。分别调用这两个对象的info方法执行打印信息功能。封装字段练习publicclassPerson{ //无参的构造函数 publicPerson(){} //有参的构造函数 publicPerson(Stringname,intage){ =name; this.age=age; } privateStringname; //姓名 publicStringgetName(){returnname;} publicvoidsetName(Stringname){=name;} privateintage; //年龄 publicintgetAge(){returnage;} publicvoidsetAge(intage){this.age=age;} //个人介绍方法 publicvoidinfo(){ System.out.println("我叫"+name+"，我的年龄是"+age); }}编写Person类：封装字段练习publicstaticvoidmain(String[]args){//声明并示例对象Personp1=newPerson();p1.setName(“小A”);p1.setAge(30);Personp2=newPerson("小红",18);//调用方法();();}编写mian主程序：第4章类的封装性、继承性、多态性及接口2.继承实现什么是继承继承：继承是面向对象最显著的一个特性。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。继承允许我们根据一个类来定义另一个类，这使得创建和维护应用程序变得更容易。同时也有利于重用代码和节省开发时间。什么是继承举个例子：人类（Person）有姓名和年龄属性，学生类（Student）有姓名、年龄、学号和班级属性。那么当我们创建学生类时，不需要完全重新编写新的数据成员和成员函数，只需要设计一个新的类，继承了已有的类的成员即可。这个已有的类被称为的基类/父类，这个新的类被称为派生类/子类。基类/父类：也可以理解成生活中的父亲，自身所拥有的一些属性方法会被继承;派生类/子类：也就是生活中的儿子，自己去继承了基类/父类的属性和方法，当然自身也会拥有自己的属性和方法。实现继承在Java之中，可以使用

extends关键字

要实现继承的关系，实现语法：子类又被称为派生类；父类又被称为超类（SuperClass）class子类extends父类{}继承练习在人类（Person）基础上，再定义一个学生类，学生类存在以下成员：一个名为name的String型的private成员变量，并封装getter和setter方法；一个名为age的int型的private成员变量，并封装getter和setter方法；一个名为id的String型的private成员变量，并封装getter和setter方法；一个名为className的String型的private成员变量，并封装getter和setter方法；编写一个测试程序，创建两个Student对象：一个人类的name=小A，age=30，id=202301，className=Java1班，另一个人类的name=小红，age=18，id=202302，className=Java2班。封装字段练习publicclassPerson{ //无参的构造函数 publicPerson(){} //有参的构造函数 publicPerson(Stringname,intage){ =name; this.age=age; } privateStringname; //姓名 publicStringgetName(){returnname;} publicvoidsetName(Stringname){=name;} privateintage; //年龄 publicintgetAge(){returnage;} publicvoidsetAge(intage){this.age=age;} //个人介绍方法 publicvoidinfo(){ System.out.println("我叫"+name+"，我的年龄是"+age); }}编写Person类：封装字段练习//学生类publicclassStudentextendsPerson{ publicStudent(Stringname,intage,Stringid,StringclassName){ super(name,age); this.id=id; this.className=className; }

privateStringid; //学号 publicStringgetId(){returnid;} publicvoidsetId(Stringid){this.id=id;} privateStringclassName; //班级名称 publicStringgetClassName(){returnclassName;} publicvoidsetClassName(StringclassName){this.className=className;}}编写Student类：封装字段练习publicstaticvoidmain(String[]args){//声明并示例对象Students1=newStudent("小A",30,"202301","Java1班");Students2=newStudent("小红",18,"202302","Java2班");//调用方法();();}编写mian主程序：第4章类的封装性、继承性、多态性及接口3.继承限制继承限制继承：面向对象程序设计的一个主要特征，是使用已经定义的类作为基础定义新类的技术。广义地说，继承是指能够直接获得已有类的性质和特征，而不要重复定义它们，因此继承是指类之间共享属性和操作的机制。在Java程序中，一个类可以通过继承另一个类，直接获取该类的属性和方法。支持多重继承结构，父类还可以继承另外一个类，Java中最大的父类是Object，如果一个类没有显式地标明继承自哪个父类，默认都是Object的子类。虽然继承可以进行类功能的扩充，但是其在定义的时候也是会存在若干种限制的。继承限制限制一：一个子类只能够继承一个父类，存在单继承局限。错误的写法：以上操作称为多重继承，实际上以上的做法就是希望一个子类，可以同时继承多个类的功能，但是以上的语法不支持而已，可以换种方式完成同样的操作。classA{}classB{}classCextendsA,B{}//一个子类继承了两个父类继承限制限制一：一个子类只能够继承一个父类，存在单继承局限。正确的写法：C实际上是属于（孙）子类，这样一来就相当于B类继承了A类的全部方法，而C类又继承了A和B类的方法，这种操作称为多层继承。继承具有传递性：子类可以继承直接父类和间接父类的所有功能。Java之中只允许多层继承，不允许多重继承，Java存在单继承局限。classA{}classBextendsA{}classCextendsB{}继承限制限制二：在一个子类继承的时候，实际上会继承父类之中的所有操作（属性、方法），但是需要注意的是，对于所有的非私有（noprivate）操作属于显式继承（可以直接利用对象操作），而所有的私有操作属于隐式继承（间接完成）。继承限制该示例无法运行，因为在B类print方法中对于A类的msg这个私有属性发现无法直接进行访问，但是却发现可以通过setter、getter方法间接的进行操作。总结：继承限制限制三：在继承关系之中，如果要实例化子类对象，会默认先调用父类构造，为父类之中的属性初始化，之后再调用子类构造，为子类之中的属性初始化。默认情况下，子类会找到父类之中的无参构造方法；如果父类没有无参构造，则子类必须通过super()调用指定参数的构造方法；super(参数列表)继承限制运行结果：实例化子类对象，会默认先执行父类构造，调用父类构造的方法体执行，而后再实例化子类对象，调用子类的构造方法。对于子类的构造而言，就相当于隐含了一个super()的形式。*************************#################继承限制栈属性方法

this78000Hsuper63000H子类对象78000HTC178000H属性方法

this63000HsuperObject父类对象63000H堆实例化子类对象时，要先实例化父类对象。在实例化过程中，Java会调用子类的构造方法，此时会先调用父类的构造方法创建父类对象，接着创建子类对象。每个对象会自动增加两个属性this和super，其中this属性指向自身首地址、super指向父类对象的首地址（其中方法指向方法区对应方法的首地址）。在调用父类构造方法时，会自动调用参数类型、个数一样的父类的构造方法，如没有带参数自动调用没有带参数的父类的构造方法等等；如果需要明确指定调用父类某个构造方法，或者子类需要调用父类的构造方法时，用关键字super进行访问，但要求必须是子类构造方法中的第一语句(和this一样)；访问子类继承父类的成员属性和方法，与访问子类自身定义的属性和方法一样。继承限制限制四：类的向下向上转型子类对象可以赋值给父类类型，反之不行；在示例中，Person为父类、Student为子类，我们可以：但不能定义Teacher对象、用Person实例化，下面定义时错误的：总结：可以定义一个父类对象、用子类实例化；不能定义一个子类对象、用父类实例化。StudentTC1=newStudent();PersonTC2=newStudent(); //定义一个父类对象，用子类实例化PersonTC21=(Student)TC2; //由于TC2本身就是一个子类对象PersonTC4=newPerson(); StudentTC1=(Student)TC4; //TC4无法通过强制类型转换赋给Student对象StudentTC3=newPerson();第4章类的封装性、继承性、多态性及接口4.方法重写主讲人：_________

什么是方法重写重写：在类继承中，子类可以修改从父类继承来的方法，也就是说子类能创建一个与父类方法有不同功能的方法，但具有相同的名称、返回值类型、参数列表。如果在新类中定义一个方法，其名称、返回值类型和参数列表正好与父类中的相同，那么，新方法被称做覆盖旧方法。参数列表又叫参数签名，包括参数的类型、参数的个数和参数的顺序，只要有一个不同就叫做参数列表不同。被覆盖的方法在子类中只能通过super调用。注意：覆盖不会删除父类中的方法，而是对子类的实例隐藏，暂时不使用。方法重写练习在人类（Person）基础上，再定义一个学生类，学生类存在以下成员：：一个名为name的String型的private成员变量，并封装getter和setter方法；一个名为age的int型的private成员变量，并封装getter和setter方法；一个名为id的String型的private成员变量，并封装getter和setter方法；一个名为className的String型的private成员变量，并封装getter和setter方法；一个名为info()的public方法实现在控制台打印信息（格式为：我叫{name}，我的年龄是{age}，我来在{className}，我的学号是{id}），返回值为void型；编写一个测试程序，创建两个Student对象：一个人类的name=小A，age=30，id=202301，className=Java1班，另一个人类的name=小红，age=18，id=202302，className=Java2班。方法重写练习publicclassPerson{ //无参的构造函数 publicPerson(){} //有参的构造函数 publicPerson(Stringname,intage){ =name; this.age=age; } privateStringname; //姓名 publicStringgetName(){returnname;} publicvoidsetName(Stringname){=name;} privateintage; //年龄 publicintgetAge(){returnage;} publicvoidsetAge(intage){this.age=age;} //个人介绍方法 publicvoidinfo(){ System.out.println("我叫"+name+"，我的年龄是"+age); }}编写Person类：方法重写练习//学生类publicclassStudentextendsPerson{ publicStudent(Stringname,intage,Stringid,StringclassName){ super(name,age); this.id=id; this.className=className; }

privateStringid; //学号 publicStringgetId(){returnid;} publicvoidsetId(Stringid){this.id=id;} privateStringclassName; //班级名称 publicStringgetClassName(){returnclassName;} publicvoidsetClassName(StringclassName){this.className=className;} //重写父类的方法——个人介绍方法 publicvoidinfo(){ Stringmsg="我叫"+getName()+"，我的年龄是"+getAge()+"，我来在"+className+"，我的学号是"+id; System.out.println(msg); }}编写Student类：方法重写练习publicstaticvoidmain(String[]args){//声明并示例对象Students1=newStudent("小A",30,"202301","Java1班");Students2=newStudent("小红",18,"202302","Java2班");//调用方法();();}编写mian主程序：重写和重载的不同方法重写要求参数列表必须一致，而方法重载要求参数列表必须不一致。方法重写要求返回类型必须一致，方法重载对此没有要求。方法重写只能用于子类覆盖父类的方法，方法重载用于同一个类中的所有方法（包括从父类中继承而来的方法）。方法重写对方法的访问权限和抛出的异常有特殊的要求，而方法重载在这方面没有任何限制。父类的一个方法只能被子类重写一次，而一个方法可以在所有的类中可以被重载多次。第4章类的封装性、继承性、多态性及接口5.final关键字主讲人：_________

什么是finalfinal关键字：final是Java中的一个关键字，可以用于修饰类、方法和变量。当一个类被声明为final时，它意味着该类不能被继承。当一个方法被声明为final时，它意味着该方法不能被重写。当一个变量被声明为final时，它意味着该变量的值不能被修改。final修饰类当用final修饰一个类时，表明这个类不能被继承。final类中的成员变量可以根据需要设为final，但是要注意final类中的所有成员方法都会被隐式地指定为final方法。在使用final修饰类的时候，要注意谨慎选择，除非这个类真的在以后不会用来继承扩展或者出于安全的考虑，尽量不要将类设计为final类。final修饰方法final修饰的方法无法被覆盖。使用final方法的原因有两个：第一个原因是把方法锁定，以防任何继承类修改它的含义；第二个原因是效率。在早期的Java实现版本中，会将final方法转为内嵌调用。但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升。在最近的Java版本中，不需要使用final方法进行这些优化了；类的private方法会隐式地被指定为final方法。final修饰变量通过示例可以了解到：如果修饰的是基本数据类型，则该引用为常量，该值无法修改；如果修饰的是引用数据类型，比如对象、数组，则该对象、数组本身可以修改，但指向该对象或数组的地址的引用不能修改。如果修饰的是类的成员变量，则必须当场赋值，否则编译会报错。classPerson{Stringname="zs";//3.此处不赋值会报错//finalintage;finalintage=10;}publicclassDemo01{publicstaticvoidmain(String[]args){//1.基本数据类型为常量，无法修改finalinti=9;//i=10;

//2.地址不能修改，但是对象本身的属性可以修改finalPersonp=newPerson();="lisi";finalint[]arr={1,2,3,45};arr[3]=999;//arr=newint[]{1,4,56,78};}}第4章类的封装性、继承性、多态性及接口6.多态实现主讲人：_________

什么是多态多态：多态性就是同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。换句话说，实际上就是同一个类型的实例调用"相同"的方法，产生的结果是不同的。这里的"相同"打上双引号是因为这里的相同的方法仅仅是看上去相同的方法，实际上它们调用的方法是不同的。多态可使代码变得简洁，使父类可以引用子类，使应用程序不必为每一个派生类编写功能调用，只需要对抽象基类进行处理即可。大大提高程序的可复用性。多态实现举个例子：一只鸡可以做成白切鸡、豉油鸡、吊烧鸡、茶油鸡、盐焗鸡、葱油鸡、手撕鸡、清蒸鸡、叫花鸡、啤酒鸡、口水鸡、香菇滑鸡、盐水鸡、啫啫滑鸡、鸡公煲等等。首先，我们先给出一只鸡：publicclassChicken{publicvoideat(){System.out.println("这是一只鸡");}}多态实现实现条件一：子类必须继承父类要实现多态，那么必定有一个作为"抽象"类（父类）来定义“行为”，以及若干个作为"具体"类（子类）来呈现不同的行为形式或形态。所以我们给出的一个具体类——白切鸡类、口水鸡：//白切鸡publicclassBaiqieChickenextendsChicken{

}//口水鸡publicclassKoushuiChickenextendsChicken{

}多态实现实现条件二：必须有重写简单地理解就是重新定义的父类方法，使得父类和子类对同一行为的表现形式各不相同。我们用白切鸡类来举个栗子——白切鸡类、口水鸡：//白切鸡publicclassBaiqieChickenextendsChicken{publicvoideat(){System.out.println("这是白切鸡");}}//口水鸡publicclassKoushuiChickenextendsChicken{publicvoideat(){System.out.println("这是口水鸡");}}这样就实现了重写，鸡类跟白切鸡类与口水鸡在eat()方法中定义的行为不同。多态实现实现条件三：父类引用指向子类对象因为父类对于子类来说，是属于“抽象”的层面，子类是“具体”的层面。“抽象”可以提供接口给“具体”实现，但是“具体”凭什么来引用“抽象”呢？而且“子类引用指向父类对象”是不符合“依赖倒置原则”的。Chickenc=newChicken();c.eat();c=newBaiqieChicken();c.eat();c=newKoushuiChicken();c.eat();运行结果：这是一只鸡这是白切鸡这是口水鸡为什么需要多态？优点：多态的出现大大的提高程序的扩展性。消除类型之间的耦合关系，也就是实现低耦合。弊端：多态不能调用子类的特有方法，需要使用到强制类型转换。第4章类的封装性、继承性、多态性及接口7.抽象类的定义和实现主讲人：_________

回答：在了解抽象类之前，先来了解一下抽象方法。抽象方法是一种特殊的方法：它只有声明，而没有具体的实现。抽象方法的声明格式为：注意：抽象方法必须用abstract关键字进行修饰。什么是抽象类提问：什么是抽象类？abstract返回值类型方法名称(形参列表);例如：abstractvoidfun();//无参数无返回值的抽象方法回答：在当父类的一个方法对于多个子类都要重写时，那父类的这个方法就没有写的必要了，所以提高编码效率，直接一个abstract方法名();。抽象方法没有具体实现，本体不能调用，普通类都可以实例化（利用new，等等），如果创建这个类的对象，并调用了这个方法，那就不会有一个合理结果。因此，需要有一个特殊的类，来定义抽象方法——抽象类什么是抽象类提问：为什么需要抽象方法？抽象类实现抽象类定义：抽象类是抽象方法与非抽象方法的集合，抽象类要使用abstract关键字声明。语法格式：例如：创建一个用户抽象类【修饰符】abstractclass类名{ //成员（构造方法、普通方法、static方法、抽象方法、常量和变量等）}publicabstractclassUser{publicabstractvoidlogin();}抽象类实现抽象类使用：抽象类无法实例化，抽象类是专门给子类继承的。final与abstract无法联合使用。抽象类虽然无法被实例化，但是抽象类有构造方法，因为抽象类有自己的一些属性。这个构造方法是给子类使用的。子类必须实现抽象类全部的抽象方法，而如果子类无法实现父类全部的抽象方法，则该子类只能定义为一个抽象父类的抽象子类。例如：创建一个学生类子类publicclassStudentextendsUser{publicabstractvoidlogin(){System.out.println("学生登录");}}抽象类和普通类的区别抽象方法必须为public或者protected（因为如果为private，则不能被子类继承，子类便无法实现该方法），缺省情况下默认为public。抽象类不能用来创建对象，即不能new。如果一个类继承于一个抽象类，则子类必须实现父类的抽象方法。如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类。在其他方面，抽象类和普通的类并没有区别。第4章类的封装性、继承性、多态性及接口8.接口的定义和实现主讲人：_________

什么是接口接口：接口(interface)是抽象方法和常量值的定义的集合。从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。接口实现定义接口：[public]interfaceinterface_name[extendsinterface1_name[,interface2_name,…]]{//接口体，其中可以包含定义常量和声明方法[public][static][final]typeconstant_name=value; //定义常量[public][abstract]returnTypemethod_name(parameter_list); //声明方法}interface_name表示接口的名称。接口名应与类名采用相同的命名规则，即如果仅从语法角度来看，接口名只要是合法的标识符即可。如果要遵守Java可读性规范，则接口名应由多个有意义的单词连缀而成，每个单词首字母大写，单词与单词之间无需任何分隔符。extends表示接口的继承关系；注意：一个接口可以有多个直接父接口，但接口只能继承接口，不能继承类。接口实现示例：定义接口publicinterfaceMylnterface{//Stringname; //不合法，变量name必须初始化intage=20; //合法，等同于publicstaticfinalintage=20;voidgetInfo(); //方法声明，等同于publicabstractvoidgetInfo();}具有public访问控制符的接口，允许任何类使用；没有指定public的接口，其访问将局限于所属的包。方法的声明不需要其他修饰符，在接口中声明的方法，将隐式地声明为公有的（public）和抽象的（abstract）。在Java接口中声明的变量其实都是常量，接口中的变量声明，将隐式地声明为public、static和final，即常量，所以接口中定义的变量必须初始化。接口没有构造方法，不能被实例化。接口实现使用接口：<public>class<class_name>[extendssuperclass_name][implementsinterface[,interface…]]{//主体}接口的主要用途就是被实现类实现，一个类可以实现一个或多个接口，继承使用extends关键字，实现则使用implements关键字。因为一个类可以实现多个接口，这也是Java为单继承灵活性不足所作的补充。类实现接口的语法格式如下：接口实现示例：实现接口publicclassMyClassimplementsMylnterface{publicvoidgetInfo(){System.out.println("实现方法");}}类使用implements关键字实现接口。在类声明中，Implements关键字放在class声明后面。一个类只能继承一个类，但是能实现多个接口。类在实现接口的方法时，不能抛出强制性异常，只能在接口中，或者继承接口的抽象类中抛出该强制性异常。类在重写方法时要保持一致的方法名，并且应该保持相同或者相兼容的返回值类型。如果实现接口的类是抽象类，那么就没必要实现该接口的方法。第4章类的封装性、继承性、多态性及接口9.接口的作用主讲人：_________

接口作用接口泛指实体把自己提供给外界的一种抽象化物（可以为另一实体），用以由内部操作分离出外部沟通方法，使其能被内部修改而不影响外界其他实体与其交互的方式。接口的作用就是把使用接口的人和实现接口的人分开，实现接口的人不必要关心谁去使用，而使用接口的人也不用关心谁实现的接口，由接口将他们联系在一起。接口是一个标准，是一个约定，而不是一种实现，接口的目的是为了规范实现类。接口优势优势1接口实现类的解耦：publicinterfaceMyInterface{publicvoiddoSomething();}publicclassMyClass1implementsMyInterface{//实现doSomething()方法}publicclassMyClass2implementsMyInterface{//实现doSomething()方法}publicclassTest{publicstaticvoidmain(String[]args){//可以通过接口类型的变量指向不同的实现类对象MyInterfacemyObj=newMyClass1();myObj.doSomething();myObj=newMyClass2();myObj.doSomething();}}接口是一种约定，它界定了实现类需要遵循的规范。通过接口，实现类与实现类之间可以完全解耦，可以方便地替换和修改实现类，而不会影响其他类的调用。接口优势优势2接口拓展的灵活性：publicinterfaceMyInterface{publicvoiddoSomething();}publicinterfaceMyInterfaceExextendsMyInterface{//继承现有接口，增加新的方法publicvoiddoSomethingElse();}publicclassMyClassimplementsMyInterfaceEx{//实现新增方法publicvoiddoSomething(){}publicvoiddoSomethingElse(){}}当业务逻辑发生变化时，添加新的业务类，并继承原有业务类，由于继承是静态的一种实现，不太灵活化的实现结构，采用接口实现的方式，接口的拓展可以轻易添加新的实现方法而保持原有的接口不被影响。接口优势优势3接口的多继承：publicinterfaceInterfaceA{publicvoidmethodA();}publicinterfaceInterfaceB{publicvoidmethodB();}publicclassMyClassimplementsInterfaceA,InterfaceB{publicvoidmethodA(){}publicvoidmethodB(){}}Java中，一个类可以继承一个类，但却可以实现多个接口，所以接口可以实现多继承的效果。通过实现多个接口，可以让实现类具备多种不同的行为和功能。接口与类相似点一个接口可以有多个方法。接口文件保存在.java结尾的文件中，文件名使用接口名。接口的字节码文件保存在.class结尾的文件中。接口相应的字节码文件必须在与包名称相匹配的目录结构中。接口与类的区别接口不能用于实例化对象。接口没有构造方法。接口中所有的方法必须是抽象方法，Java8之后接口中可以使用default关键字修饰的非抽象方法。接口不能包含成员变量，除了static和final变量。接口不是被类继承了，而是要被类实现。接口支持多继承。抽象类和接口的区别抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是publicstaticfinal类型的。接口中不能含有静态代码块以及静态方法(用static修饰的方法)，而抽象类是可以有静态代码块和静态方法。一个类只能继承一个抽象类，而一个类却可以实现多个接口。publicabstractclassUser{publicvoidmsg(){System.out.println(“有方法体”);}publicabstractvoidlogin();Stringname=“成员变量”;static{System.out.println(“静态代码块”);}}publicinterfaceUser{voidlogin();publicstaticfinalStringname=“成员变量”;}抽象类接口VS什么时候使用抽象类和接口如果你拥有一些方法并且想让它们中的一些有默认实现，那么使用抽象类吧。如果你想实现多重继承，那么你必须使用接口。由于Java不支持多继承，子类不能够继承多个类，但可以实现多个接口。因此你就可以使用接口来解决它。如果基本功能在不断改变，那么就需要使用抽象类。如果不断改变基本功能并且使用接口，那么就需要改变所有实现了该接口的类。接口的应用适合框架开发在Java的框架开发中，接口占据着非常重要的地位。比如Servlet、JDBC接口等，这些接口为框架提供了标准的约定和规则，并在其基础上进行实现和拓展。开发者可以通过实现这些接口，来创建自己的实现类，再与框架进行对接。适合多线程开发在多线程开发中，Java的接口可以被当做是线程间通讯的一种手段，通过实现不同的接口，线程之间可以进行数据和状态的交换和传递。适合单元测试接口有助于单元测试的编写。单元测试时，通过实现接口的方式，可以为被测试的类注入不同的实现类，来测试不同的业务逻辑，实现Mock测试。总结综上所述，Java接口作为一种重要的面向接口编程机制，可以用来实现代码的复用、拓展和解耦，可以提高程序的灵活性和可维护性。因此，Java接口在Java开发中不可缺少，不同之处直接映射出Java语言的特性和魅力。第4章类的封装性、继承性、多态性及接口10.内部类介绍主讲人：_________

什么是内部类内部类：可以将一个类的定义放在另一个类的定义内部，这就是内部类。示例：publicclassA{//外部类的成员

publicclassB{//内部类的成员}}在类A中定义类B，那么类B就是内部类，也称为嵌套类，相对而言，类A

就是外部类。如果有多层嵌套，例如类A中有内部类B，而类B中还有内部类C，那么通常将最外层的类称为顶层类（或者顶级类）。什么是内部类示例：publicclassA{//外部类的成员

publicclassB{//内部类的成员}}内部类在编译完成后也会产生.class文件，但文件名称是：外部类名称$内部类名称.class，例如：A$B.class。内部类是一个非常有用的特性但又比较难理解使用的特性。内部类分类分类：成员内部类、静态内部类、局部（方法）内部类、匿名内部类。成员内部类介绍：成员内部类也叫实例内部类。应用场景：每一个外部类对象都需要一个内部类的实例，内部类离不开外部类存在（相当于心脏对人体）。特征：作为外部类的一个成员存在，与外部类的属性、方法并列。成员内部类持有外部类的引用。成员内部类中不能定义static变量和方法。成员内部类定义格式：[访问修饰符]class类名{[访问修饰符]class内部类名{ 属性成员 方法成员}属性成员方法成员}注意：内用外，随便访问；外用内，需要内部类对象（即实例化new）。成员内部类使用格式：间接方法在外部类的方法中使用内部类；其他类只是调用外部类方法。成员内部类使用格式：直接方法即直接实例化内部类。实现外部类使用：内部类名称对象名=new内部类名称();其他类使用：外部类名称.内部类名称对象名=new外部类名称().new内部类名称();成员内部类重名的变量的使用方法：如果出现了重名现象，