day09总结

Day09总结： 上午：

1、final关键字： Eg:代码实现： Class Fu { Final void method() { //code...访问低层代码 } }

Class Zi extends Fu { Void method() { Sop(\"haha\"); } }

以上代码体现出继承的弊端，因为父类的method的方法访问了系统的低层代码。当子类对其覆写，就不会去访问父类的meth的方法，直接用自己的method这样就出现了代码的不严谨性，所以此时需要用final关键字进行修饰。 注意为什么不把类加final修饰，因为可能该类中会出现很多功能。有些是不需要被覆写的。有些是被调用的。所以只能根据自己所需对相应的成员进行修饰。 2、Final的特点：

1、final是一个修饰符，可以修饰类、方法、变量(成员变量、局部变量) 2、Final修饰的类不可以被继承。 3、Final修饰的方法不可以被覆盖。

4、Final修饰的变量是一个常量，只能被赋值一次。是为了增强阅读性，只要数据是固定的，就将这个数据用一个名称来表示，并用final修饰。常量名称都是大写字母，多个单词组成时用下划线来分隔。 代码体现： Eg: Class Zi { Static final int num=90; //必须对变量进行初始化，不知道要最终化哪个值，所以必须对它进行初始化。加静态也是一样的，同样的道理，并且被初始化，此时静态和final没有必然的联系。当变量被final修饰时，说明变量已经是一个常量值，此时不能被修饰，可以用static来修饰。 Public stati double PI=3.14; Void method() { Final int x=4; X=8;

传智播客--------------------------------------------java基础 许正

Sop(num);//既然是在操作一个固定的值。为什么不把4直接写在此处，如果这样做的的话，阅读性极差，你根本就不知道它所代表什么？为了增强阅读性，此时数据是不变化的，所以我们需要给它起个名字，并且用final来修饰。这样的话它也是固定的不变的。

注意：被final修饰的数值只能被覆写一次，并且修饰的常量名全部大写，多个单词组成时用下划线进行分隔。Eg:final int PERSON_AGE=4; } }

3、抽象类：

特点：

1、没有方法体的方法，称为抽象方法，必须存放在抽象方法类中，抽象方法和抽象类必须用abstract关键字来修饰，

2、抽象类不可以被实例化，为什么？因为调用抽象方法没有意义？为什么？因为它连方法体都不存在？

3、抽象类必须由其子类将抽象类中的抽象方法都覆盖后，其子类才可以被实例化，否则该子类还是抽象类。 Eg:

Abstract class Demo { Abstract void show(); }

Class SubDemo extends Demo Void show(){} //此时把父类中抽象方法覆盖，此时才能被实例化。 }

比如水果，它就是抽象的，不具体它包含各种各样的水果，每种水果有它自己的体现。

抽象类涉及的问题？

1、抽象类中是否可以定义非抽象的方法？

可以 首先抽象类是一个类，类是用来描述事物，只不过描述事物过程中有些信息不具体，抽象类和一般类异同点：

相同：抽象类和一般类都用于描述事物，都可以定义成员。 不同：抽象类中可以定义抽象成员函数，（抽象要么修饰类要么修饰函数）而一般类不可以。

抽象类不可以实例化，一般类可以实例化。 2、抽象类中是否有构造函数？

有，而且抽象类虽然自身不可以被实例化，但是其子类覆盖了所有的抽象方法后，是可以实例化的。所以抽象类的构造函数是用于给其子类对象进行实例化。

3、抽象类通常都是一个父类？

是、因为需要子类去覆盖父类中的抽象方法。 代码体现：

Abstract class Demo{ Abstract voif show1();

传智播客--------------------------------------------java基础 许正

Abstract void show2(); }

Abstract class SubDemo extends Demo { Void show1(); }

Class Test extends SubDmeo { Void show2(); }

4、抽象类中可不可以不定义抽象方法？ 可以；看上去没有什么意义，其实有点意义，就是不让这个类创建对象，为什么不让创建？ 代码体现：

interface InterTest//这是一个测试接口，有4种测试方式。 { void test1(); void test2(); void test3(); void test4(); } abstract class InterTestImpl implements InterTest//用这个类进行所有的空实现。但是创建对象是毫无意义的。所以用抽象。 { public void test1(){} public void test2(){} public void test3(){} public void test4(){} }

class Test2 extends InterTestImpl { public void test2(){} }

class Test3 extends InterTestImpl { public void test3(){} } /*

class InterTestImpl implements InterTest { public void test2()// { sop(\"testimpl test2\");

传智播客--------------------------------------------java基础 许正

} public void test1(){}//这样做实现太麻烦。代码重复。如何改进？ public void test3(){} public void test4(){} } */

5、抽象关键字 不可以和那些关键字共存？ Final：修饰了类是一个最终类，不可以被继承，然后abstract修饰的类必须是父类，需要被继承、冲突、非法的修饰符组合，abstract 和final Static:抽象方法被static修饰，就具备了可以被类名直接调用的的特点，但是抽象方法被调用没有意思。 Priavte：因为抽象方法被私有，无法被覆盖。

代码体现： 雇员实例：

需求：公司中程序员有姓名、工号、薪水、工作内容。 项目经理除了姓名、工号、薪水、还有奖金、工作内容 进行数据建模 做问题领域的分析就是找出问题领域的对象。

分析:

在这个问题领域中有两个对象： 程序员： 属性：姓名，工号，薪水 行为：工作内容 项目经理： 属性：姓名、工号、薪水、奖金 行为：工作内容。 这时候不能用项目经理去继承程序员。因为职能不同，但是有共性，只能抽取。 就有了员工： 属性：姓名，工号，薪水 行为：工作内容 */

abstract class Employee { private String name; private String id; private double pay; Employee(String name,String id,double pay) { this.name=name; this.id=id;

传智播客--------------------------------------------java基础 许正

this.pay=pay; } public abstract void work();//工作内容是无法知道的。 }

class Programmer extends Employee { Programmer(String name,String id,double pay) { super(name,id,pay); } public void work() { System.out.println(\"code\"); } }

class Manager extends Employee { private double bonus; Manager(String name,String id,double pay) { super(name,id,pay); this.bonus=bonus; } public void work() { System.out.println(\"manage\"); } }

4、接口：

格式：interface{} 表现特点：

1、里面的方法都是抽象的。

2、接口中的成员都有固定的修饰符，最常见的成员：全局常量抽象方法。只是最常见，不代表只有它们没有其他的，

全局常量，共有的不需要对象，直接用接口调用的，不可变的。 表现形式：Public static final 抽象方法：public abstract

3、接口的成员都是public的。

4、接口是不可以创建对象的。就相当于是抽象的特殊表达形式。（但是有区别和抽象类）

5、类与类之间是继承关系，类与接口之间是实现关系。 6、接口的出现可以多实现，避免了单继承的局限性。

传智播客--------------------------------------------java基础 许正

7、一个类在继承一个类的同时，还可以实现多个接口、

8、接口与接口之间是继承关系，而且可以多继承，以为接口的方法都没有主体。 思想特点：

1、对外暴露的规则。

外设要介入计算机中，因为计算机外面提供了接口，这就是规则。

2、程序的功能扩展 3、降低了耦合性 4、用来多实现

结合电脑主板的思想进行阐述，它是个规则，。对外提供的规则 它提高了我们功能的扩展性，降低了耦合性。 主板和声卡：主板使用规则，声卡实现规则。

与抽象类的区别：抽象类有单继承的局限性，接口没有

5、java对多继承记住改良，以多现实接口的方式来体现。 差别：多继承因为父类中有相功能时，会造成不确定性。 为什么可以实现多实现？

因为继承中父类的方法有方法体？这才是造成不确定性的根本原因，而此处是没有方法体的。

代码体现： interface A { //int show();//这样是不可以的。无法覆盖。 void show(); } interface B { // void method(); void show();//当有重复的方法时。但是此时子类复写它是可以的，为什么？ //因为继承中父类的方法有方法体。这才是造成不确定性的根本原因。而 //此处是没有方法体的。 } class C extends D implements A,B//多实现。此时c必须覆盖两个方法 { public void show(){} //public void method(){} } //一个类在继承一个的类的时候还可实现多实现 class D {

传智播客--------------------------------------------java基础 许正

public void function(); } //接口之间是可以继承，而且支持多继承。 interface InterA { void showA(); } interface InterB { void showB(); } interface InterC extends InterA,InterB//为什么此处可以实现多继承，因为方法没有主体。 { void showC(); } class InterfaceDemo2 { public static void main(String[] args) { C c=new C(); c.show(); System.out.println(\"Hello World!\"); } }

6、抽象类和接口之间的区别：

共性：它们都是不断抽取出来的抽象非概念

区别：1、抽象类只能被单继承、接口可以被多实现，避免了单继承的局限性。 2、抽象类中可以定义抽象方法，和非抽象方法，它可以用于定义体系的基本共性的内容。接口中只能定义抽象方法，它主要用于对象的功能的扩展。 3、抽象类是继承关系，是is a关系，接口是实现关系是like a关系。 4、抽象类中的成员修饰符都是自定义的，接口中的修饰符都是固定的。 记住：不要把接口狭义的理解为interface,应该理解广义些，就是对外提供的规则，凡是对外暴露的都可以是接口。

实现代码：

1、 abstract class 犬 { public abstract void 吃饭(); public abstract void 吼叫(); }

interface 搜爆 {

传智播客--------------------------------------------java基础 许正

public void 搜爆(); }

class 搜爆犬 extends 犬 implements 搜爆//这是即具备了犬的基本特性，又具备了搜爆功能。

{ public void 搜爆(){} public void 吃饭(){} public void 吼叫(){} }

class 搜爆猫 extends 猫 implements 搜爆 { public void 搜爆(){} }

记住： 类里面都是定义的一些基础内容，接口里面都是定义一些特性内容，这样的方便了对其进行扩展。

//抽烟的学生，抽烟是额外功能。 2、abstract class Student { abstract void study(); }

interface Smoking { void smoke(); }

class SomkeStudent extends Student implements Smoking { public void study(){} public void smoke(){} }

//烟民。学生烟民 问题领域不同，对象的属性和行为也不同。 abstract class Somker { abstract void smoke(); }

interface Study { void study(); }

class StudentSmoker extends Smoker implements Study { public void smoke(){} public void study(){} }

传智播客--------------------------------------------java基础 许正

7、多态：重点掌握

定义：某一类事物的多种存在形态。 代码实现： class 动物 {}

class 猫 extends 动物 { }

猫 x=new 猫();

动物 y=new 猫();//父类的引用变量指向了其子类的对象。

多态在代码中的体现，父类或者接口的引用指向了自己的子类对象。 实现代码： class Animal { abstract void eat(); }

class Dog extends Animal { void eat() { sop(\"啃骨头\"); } void lookHome() { sop(\"看家\"); } }

class Cat extends Animal { void eat() { sop(\"吃鱼\"); } void catchMouse() { sop(\"抓老鼠\"); } }

class Pig extends Animal { void eat()

传智播客--------------------------------------------java基础 许正

{ sop(\"猪饲料\"); } void gongdi() { sop(\"拱地\"); } }

class DuoTaiDemo { public static void main(String[] args) { //Cat c=new Cat(); //c.eat(); //Cat c1=new Cat(); //c1.eat(); //method(c); //method(c1); 重要知识点：----开发都用！ Animal a=new Cat();//此处猫对象类型自动向上提升---向上转型，当指向使用体系基本功能时，可以向上转型操作。 为什么体现多态性？ 首先猫是一个实体，是一个猫类型，因为有了继承，是动物中的一种，把这个实体称之为动物也可以，所以它具备了两种形态，猫和动物。这便是体现了多态性。 //一旦向上转型，猫就不是猫了，已经是动物类型了。 a.catchMouse();//编译失败。 但是现在想执行猫的抓老鼠的功能怎么办？ 向下转型： Cat c=(Cat)a;//向下转型。当使用子类对象中的特有内容时，才做向下转型。 c.eat(); c.catchMouse();//此时是可以实现猫的抓老鼠的功能的。 总结：在多态转型中，至始至终只有子类对象做着类型的变化。 method(new Cat()); } public static void method(Animal a)//Animal a=new Cat(); { 重点知识点：instanceof if(a instanceof Cat)//对象instanceof 类型 判断具体对象是否是指定的类

传智播客--------------------------------------------java基础 许正

型。 { Cat c=(Cat)a;//编译通过，但是不能运行，此时类型转换异常classCastException; //此时为了程序的严谨性，需要对传入的的对象进行判断。 c.catchMouse(); } else if(a instanceof Dog) { Dog d=(Dog)a; d.lookHome(); } a.eat(); 总结： instanceof是一个关键字，用于判断对象的类型。什么时候用？ 当进行向下转型时，先判断该对象是否符合被转成的子类型。 } }

8、重点理解：

1、多态的好处：提高了代码的扩展性，有了多态，前期设计好的内容可以使用后期出现的子类内容，对于指挥对象做事情这件事情，如果对象很多，指挥起来很麻烦，抽取对象的共性类型，对该类型的事物进行指挥就会变的很简单。

2、多态的前提：1、必须要有关系：继承、实现。 2、必须有覆盖的操作。

3、多态的弊端：前期的程序虽然可以使用后期出现的子类内容，但是只能使用子类覆盖父类中的内容，不能使用子类中的特有内容。