黑马程序员java培训就业班笔记day09总结.doc

黑马程序员java培训就业班笔记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;
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();
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");
}
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;
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、 接口的出现能够多实现，避免了单继承的局限性。
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
{
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 搜爆
{
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(){}
}

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()
{
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 类型 判断具体对象是否是指定的类型。
{
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、多态的弊端：前期的程序虽然能够使用后期出现的子类内容，可是只能使用子类覆盖父类中的内容，不能使用子类中的特有内容。