一面向对象三大特征-继承：
概述：把很多类的相同特征和行为进行抽取，用一个类来描述。让多个类和这个类产生一个关系。这样的话，多个类就可以省略很多代码。这个关系就是继承。java中用extends关键字表示。
A好处：
1.提高了代码的复用性
2.让类与类之间产生了关系，有了这个关系，才有了多态的特性。必须是类与类之间有所属关系才可以使用继承。
B继承的特点
1java只支持单继承，不支持多继承，多继承容易带来安全隐患：当多个父类中定义了多个相同功能，当功能内容不相同时，不确定调用了父类的哪一个。但是java可以通过多实现来实现。
2Java同时支持多层继承。
先要使用集成体系，先要查阅父类的功能，因为父类中定义的是该体系中的共性功能，通过了解共性功能，就知道该体系的基本功能。
调用时要创建最子类的对象，原因是：
1.因为有可能父类不能创建对象
2.创建子类对象可以使用更多功能，包括基本的也包括特有的。
C子父类出现后类成员的特点：
1.子父类中变量的特点：
父类的成员变量私有化之后，子类依然继承，但不能直接访问。
如果子类中出现非私有的同名成员变量时，需要访问本类中的变量用 this，要访问父类中的同名变量，用super，
super的使用和this的使用 几乎一致。
this：本类对象的引用
super：父类对象的引用。一定要放在子类函数的第一行。
2.子父类中函数的特点：--覆盖（override）
当子类中出现和父类一模一样的函数时，当子类对象调用该函数，会运行子类函数的内容，如同父类的函数被覆盖一样。这就是重写。
当子类继承了父类，沿袭了父类的功能，到子类中，但是子类虽然具备该功能，但是功能的内容却和父类不一样，这是没有必要定义新功能，而是使用覆盖特性，保留父类的功能定义，并重写功能内容。
注意：
1）.子类覆盖父类，必须保证子类权限大于等于父类权限，才能重写。
2）.静态只能覆盖静态。
3重载和重写：
重载：只看同名函数的参数列表
重写：功能定义要一模一样。
3.子父类中构造函数的特点：
1在对子类对象进行初始化时，父类的构造函数也会运行，那是因为子类的构造函数。子类只会隐式调用父类的空参构造函数。
2子类一定会访问父类中的构造函数：
因为父类中的数据子类可以直接获取，所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的。所以子类在对象初始化时，要先访问一下父类中的构造函数。如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来指定。子类的所有构造函数，默认都会访问父类中孔参数的构造函数，因为子类的每一个构造函数内的第一行都有一句隐式super（）；
当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问父类中的构造函数。
当然子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数，子类中至少会有一个构造函数会访问父类中的构造函数。
注意：super语句一定定义在子类构造函数的第一行。因此super和this在构造函数中只能出现一个。
final关键字
最终，作为一个修饰符
1.可以修饰类类 函数 变量
2.被final修饰的类不可以被继承，为了避免被继承时，被子类复写。
3.被final修饰的方法不能被复写。
4.被final修饰的变量是一个常量只能赋值一次，既可以修饰成员变量，也可以修饰局部变量。
在描述一些事物时，一些数据的出现值是固定的，那么为了增强阅读性，都给这些值起个名字，方便阅读，而这个值不需要改变时，
加上final修饰，作为常量。书写范围所有字母都大写，用_连接。
常量定义一般都是 public权限 、静态的。
抽象类：abstract。
当多个类中出现相同功能，但是功能主体不同，这时候可以进行向上抽取，只抽取功能定义，而不抽取功能主体。，分析事物不确定时，就抽象，需要被指定关键字abstract所标示。
特点
1.抽象方法只能定义在抽象类中。
2.抽象方法和抽象类必须被abstract修饰
3.抽象类不可以用new 创建对象，因为创建对象没有意义
4.抽象类中的抽象方法要被使用，必须由子类复写抽象方法后，建立子类对象调用，
注意：
1如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。如果不想子类是抽象类必须，复写父类抽象类中的全部抽象方法。
2抽象类中不一定要存在抽象方法。
不能与abstract共存的关键字
private：私有内容子类无法继承，子类无法复写，与抽象必须复写冲突
final： final修饰成员不能修改，也就不能复写，与抽象必须复写冲突
static： static修饰成员可以直接用类名调用，而抽象中没有方法体，没有意义。
总结：
其实，抽象类和一般类没有太大的区别，都是在描述事物，只不过抽象类在描述事物时，有些功能不具体。所以抽象类和一般类在定义上，都是需要定义属性和行为的。只不过，比一般类多了一个抽象方法。而且比一般类少了一个创建对象的部分。
例子：
abstract class enmployee{
private String name;
private int id;
private double money;
public enmployee(String name, int id, double money) {
super();
this.name = name;
this.id = id;
this.money = money;
}
public abstract void work();
}
class yuangong extends enmployee{
public yuangong(String name, int id, double money)
{
super(name, id, money);
}
public void work(){
//员工工作
}
}
class jingli extends enmployee{
double jiangjin;
public jingli(String name, int id, double money,double jiangjin) {
super(name, id, money);
this.jiangjin=jiangjin;
}
public void work(){
//经理工作
}
}
模板方法模式：在定义功能时，功能的一部分是确定的，但有一部分是不确定的，在使用不确定的部分。就将不确定的部分暴露出去。由该来的子类去实现。将确定的部分final修饰 ，禁止修改。
代码示例：
abstract class GetTime{
public final void getTime(){ //此功能如果不需要复写，可加final限定
long start = System.currentTimeMillis();
code(); //不确定的功能部分，提取出来，通过抽象方法实现
long end = System.currentTimeMillis();
System.out.println("毫秒是："+(end-start));
}
public abstract void code(); //抽象不确定的功能，让子类复写实现
}
class SubDemo extends GetTime{
public void code(){ //子类复写功能方法
for(int y=0; y<1000; y++){
System.out.println("y");
}
}
}
接口：interface，
当抽象类中的方法都是抽象的时，java中提供了另一种表示方式-接口。用interface关键字表示。类与接口关系用implements表示。接口是不可以创建对象的，因为有抽象方法，需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化，否则子类是一个抽象类。
接口的特点：
1.接口中的成员都有默认固定修饰符
常量 public static final
方法 public abstract
2接口中的成员都是public的。
3:是对外暴露的规则
4:是功能的扩展
5:接口的出现降低偶合性。
偶合(类与类之间的关系)
内聚(类完成功能的能力)
编程规范：低偶合，高内聚。
6:接口可以多实现。如：CPU和主板、笔记本的USB插口、插座
7:类和接口的关系
是实现关系。类可以多实现接口。
类在继承一个类的同时，可以实现多个接口。
8:接口和接口的关系
是继承关系。接口可以多继承接口
2接口和抽象类的区别
A：继承
抽象类只能被单继承
接口可以多实现,接口的出现避免了多继承的局限性。
B：数据特点
抽象类中的数据特点：
成员变量：可以是变量，也可以是常量
成员方法：可以是抽象方法，也可以是非抽象方法
构造方法：有构造方法
接口中的数据特点：
成员变量：是常量。默认修饰 public static final
成员方法：都是抽象方法。都有默认修饰 public abstract
构造方法：没有构造方法
C：抽象类中定义的是继承体系中的共性功能。
接口中定义的是继承体系中的扩展功能。
D：抽象类被继承是"is a"关系:xx是yy的一种
接口被实现是"like a"关系:xx像yy的一种
面向对象三大特性-多态
概述：同一个对象，在程序不同时刻的多种运行状态。举例：动物，狗是狗，狗是动物。可以理解为事物存在的多种体现形态。多态的出现使编程思想上也做着变化;以前是创建对象并指挥对象做事情。有了多态以后，我们可以找到对象的共性类型，直接操作共性类型做事情即可，这样可以指挥一批对象做事情，即通过操作父类或接口实现。
父类的引用指向子类的对象。
1.多态的体现
父类的引用指向子类的对象，父类的引用接收子类的对象。
2.多态的前提
类与类之间必须是继承或者实现的关系。通常还有一个前提 就是覆盖
3.多态的好处
大大的提高了程序的扩展性
4.多态的局限性
提高了扩展性，但是只能使用父类的引用访问父类中的成员。
5 关键字：instanceof用于判断某个对象是否属于指定类型。
格式：
对象 instanceof 类型；
返回值为boolean型。
6 多态中成员的特点
1，成员变量：在多态中，子父类成员变量同名。
在编译时期：参考的是引用型变量所属的类中是否有调用的成员。（编译时不产生对象，只检查语法错误）
运行时期：也是参考引用型变量所属的类中是否有调用的成员。
简单一句话：无论编译和运行，成员变量参考的都是引用变量所属的类中的成员变量。
再说的更容易记忆一些：成员变量 ---编译运行都看 = 左边。
2， 成员函数。
编译时期：参考引用型变量所属的类中是否有调用的方法。
运行事情：参考的是对象所属的类中是否有调用的方法。
为什么是这样的呢？因为在子父类中，对于一模一样的成员函数，有一个特性：覆盖。
简单一句：成员函数，编译看引用型变量所属的类，运行看对象所属的类。
更简单：成员函数 ---编译看 = 左边，运行看 = 右边。
3， 静态函数。
编译时期：参考的是引用型变量所属的类中是否有调用的成员。
运行时期：也是参考引用型变量所属的类中是否有调用的成员。
为什么是这样的呢？因为静态方法，其实不所属于对象，而是所属于该方法所在的类。
调用静态的方法引用是哪个类的引用调用的就是哪个类中的静态方法。
简单说：静态函数 ---编译运行都看 =左边。
代码示例
class 毕姥爷{
void 讲课(){
System.out.println("企业管理");
}
void 钓鱼(){
System.out.println("钓鱼");
}
}
class 毕老师 extends 毕姥爷{
void 讲课(){
System.out.println("JAVA");
}
void 看电影(){
System.out.println("看电影");
}
}
class {
public static void main(String[] args)
{
毕姥爷 x = new 毕老师(); //毕老师对象被提升为了毕姥爷类型。
// x.讲课();
// x.看电影(); //错误.
毕老师 y = (毕老师)x; //将毕姥爷类型强制转换成毕老师类型。
y.看电影();//在多态中，自始自终都是子类对象在做着类型的变化。
}
}
--------------------- android培训、java培训、java学习型技术博客、期待与您交流！ -------------------
255
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
