关于面向对象那点事【xiao金刚】
最近比较忙，没时间上来看大家。这段时间一直在学习，还要出去兼职（锻炼社交能力）。一直没能做好技术总结这件事。现在把继承与接口这部分的内容做一个总结：
一、面向对象编程思想的三大特点是什么？
1、 继承：继承是指一个类是从另一个类派生而来的，派生类自动具有了被继承类的所有特性。其中，被继承的类叫做父类、基类，继承父类的类叫做子类、派生类或者超类。
2、 多态：多态是指一个东西，不同的情况下呈现出不同的状态，实现不同的功能。静态多态的主要实现形式有函数重载、继承和方法重写，动态多态的理论基础是父类引用可以指向子类对象(即自动转型)。
3、 封装：封装是指隐藏对象的属性及实现细节，对外仅提供接口可见。封装实现了信息隐藏，有利于软件复用。封装使用主要是通过访问控制符public、protected、private和default。
二、继承的语法格式是？子类能继承到父类的哪些方法和属性？
java的继承关键字是：extends
格式：
public class 子类名 extends 父类名 ｛
}
子类又可以叫做超类。
父类又可以叫做基类。
java中类只能继承一个父类。类的继承是单继承。
1.子类和父类在同一个包下：
public、protected、default的属性和普通方法能被子类继承到，并且直接通过对象名就可以使用。
私有的属性和私有方法不能被子类继承。
构造方法也不能被子类继承。
2.子类和父类不在同一个包下：
公有的属性和普通方法能被子类继承到，并且直接通过对象名就可以调用。
这里注意：不同包下protected的属性和方法是不可以被继承的。
代码验证如下：
这是A类和还有包名
package
public class A {
public int m=888;
protected int n=999;
}
这个是B类和包名，引入了A类的包名
package 练习;
import
public class B extends A{
public static void main(String[] args) {
A a =new A();
System.out.println("m是："+a.m+"n是："+a.n); //结果显示n要变为public才可
}
}
三、多态的一些实现方式有什么东东？
多态是由java的方法重载，继承，方法重写，自动转型等技术的组合。
（这里一部分是摘草毕向东老师的视频教程方法的，感觉这个例子好理解，如果再不懂得继续看下面的例子）
程序代码：/*
对象的多态性。
class 动物
{}
class 猫 extends 动物
{}
class 狗 extends 动物
{}
猫 x = new 猫();
动物 x = new 猫();//一个对象，两种形态。
猫这类事物即具备者猫的形态，又具备着动物的形态。
这就是对象的多态性。
简单说：就是一个对象对应着不同类型.
多态在代码中的体现：
父类或者接口的引用指向其子类的对象。
多态的好处：
提高了代码的扩展性，前期定义的代码可以使用后期的内容。
多态的弊端：
前期定义的内容不能使用(调用)后期子类的特有内容。
多态的前提：
1，必须有关系，继承，实现。
2，要有覆盖。
*/
abstract class Animal
{
abstract void eat();
}
class Dog extends Animal
{
void eat()
{
System.out.println("啃骨头");
}
void lookHome()
{
System.out.println("看家");
}
}
class Cat extends Animal
{
void eat()
{
System.out.println("吃鱼");
}
void catchMouse()
{
System.out.println("抓老鼠");
}
}
class Pig extends Animal
{
void eat()
{
System.out.println("饲料");
}
void gongDi()
{
System.out.println("拱地");
}
}
class DuoTaiDemo
{
public static void main(String[] args)
{
// Cat c = new Cat();
// c.eat();
// c.catchMouse();
Animal a = new Cat(); //自动类型提升，猫对象提升了动物类型。但是特有功能无法s访问。
//作用就是限制对特有功能的访问。
//专业讲：向上转型。将子类型隐藏。就不用使用子类的特有方法。
// a.eat();
//如果还想用具体动物猫的特有功能。
//你可以将该对象进行向下转型。
// Cat c = (Cat)a;//向下转型的目的是为了使用子类中的特有方法。
// c.eat();
// c.catchMouse();
// 注意：对于转型，自始自终都是子类对象在做着类型的变化。
// Animal a1 = new Dog();
// Cat c1 = (Cat)a1;//ClassCastException
/*
Cat c = new Cat();
// Dog d = new Dog();
// c.eat();
method(c);
// method(d);
// method(new Pig());
*/
method(new Dog());
}
public static void method(Animal a)//Animal a = new Dog();
{
a.eat();
if(a instanceof Cat)//instanceof：用于判断对象的具体类型。只能于引用数据类型判断
// //通常在向下转型前用于健壮性的判断。
{
Cat c = (Cat)a;
c.catchMouse();
}
else if(a instanceof Dog)
{
Dog d = (Dog)a;
d.lookHome();
}
else
{
}
}
/*
public static void method(Cat c)
{
c.eat();
}
public static void method(Dog d)
{
}
*/
}
/*
多态时，
成员的特点：
1，成员变量。
编译时：参考引用型变量所属的类中的是否有调用的成员变量，有，编译通过，没有，编译失败。
运行时：参考引用型变量所属的类中的是否有调用的成员变量，并运行该所属类中的成员变量。
简单说：编译和运行都参考等号的左边。哦了。
作为了解。
2，成员函数(非静态)。
编译时：参考引用型变量所属的类中的是否有调用的函数。有，编译通过，没有，编译失败。
运行时：参考的是对象所属的类中是否有调用的函数。
简单说：编译看左边，运行看右边。
因为成员函数存在覆盖特性。
3，静态函数。
编译时：参考引用型变量所属的类中的是否有调用的静态方法。
运行时：参考引用型变量所属的类中的是否有调用的静态方法。
简单说，编译和运行都看左边。
其实对于静态方法，是不需要对象的。直接用类名调用即可。
1. 方法重写(overwrite)
要实现方法重写必须满足的条件是：
方法的访问修饰符，方法返回值类型，方法名，方法所带的参数个数，参数类型和参数的顺序都必须要和父类的完全相同。
当实现方法重写后：
实例化的对象是子类的对象时，那么会优先调用子类中的方法，如果子类中没有这个方法，那么则调用父类的方法
2. 方法重载(overload)
在一个类中，定义多个同名，但参数类型和数量不同的方法，叫做方法的重载。
下面以构造函数做一举例说明：
这是A类
public class A {
public String x = null;
public int y = 0;
public A(String x, int y) {
this.x = x;
this.y = y;
System.out.println("构造函数中传入了一个字符串和整型数据");
}
public A(String x) {
this.x = x;
System.out.println("构造函数中传入了一个字符串");
}
public A() {
System.out.println("构造函数中什么都没有");
}
}
这是B类
public class B extends A{
public static void main(String[] args) {
A a =new A();
System.out.println("x是"+a.x+"\ty是"+a.y);
A b =new A("我爱你");
System.out.println("x是"+b.x+"\ty是"+b.y);
A c =new A("我爱你",520);
System.out.println("x是"+c.x+"\ty是"+c.y);
}
}
结果是：
构造函数中什么都没有
x是null y是0
构造函数中传入了一个字符串
x是我爱你 y是0
构造函数中传入了一个字符串和整型数据
x是我爱你 y是520
3. 自动转型
换句话讲，可以这么解释通，即：父类引用可以指向子类对象。可以延伸到以下两个方面：
1. 函数传入的形参可以是父类类型，实际传入的可以是子类对象
代码演示如下
public class Main{
public static void fun(Dialog dialog){
dialog.show();
}
public static void main(String[] args){
fun(new FontDialog());
}
}
2. 函数的返回类型是父类类型，实际返回的可以是子类对象
代码演示如下
public class Main{
public static Dialog fun(){
return new FontDialog();
}
public static void main(String[] args){
Dialog dialog = fun();
}
}
实现自动转型的条件：必须要存在继承关系。
四、接口和抽象类的一些东西…
接口的定义
接口是面向对象编程中的又一重要概念，接口只定义提供什么功能，而不定义功能的具体实现。这在程序设计中非常有帮助。
定义接口的关键字是interface
格式：
public interface 接口名 extends 接口名,... {//接口也可以通过extends继承接口
//常量,常量的值是不能被改变
public static final 数据类型常量名 = 值;//这三个关键字都是默认的
//抽象方法
public 返回值数据类型 方法名(数据类型参数名,...);
}
注意：1.接口中默认的访问修饰符是public
2.接口是不能实例化对象的。
降低程序的高耦合低内聚,即:使程序 “低耦合、高内聚”
接口的实现
实现接口的关键字是implements
格式
public class 类名 extends 类或抽象类 implements 接口名,... {
//必须要实现接口中所有的抽象方法。
}
类可以继承类，再去实现接口吗？ 可以的
抽象类的定义和继承
定义的关键字是abstract class
继承的关键字是extends
格式：
public abstract class 抽象类名 extends 类或抽象类 implements 接口,... {
//类中任何的方法和属性都可以在抽象类中定义。
//接口中的常量和抽象方法也可以在抽象类中定义。但是抽象方法的格式稍有不同，
public abstract 返回值数据类型 方法名(数据类型 参数名,...);
}
抽象类就是介于类和接口的一中特殊类。
抽象类至少包含一个抽象方法。
抽象类也不能实例化对象。
抽象函数必须被重写，除非子类也是抽象函数。
抽象类中可以含有普通函数。
抽象了介于类和接口之间，可以有实现的，也可以有未实现的方法，常用作“适配器”，这样我们便没必要实现接口中所有的方法了，只需取出所需要的就好了一个抽象类和接口的典型应用是MouseAdapter和MouseListener。
五、内部类和匿名内部类是神马东东？
内部类是指在类的内部嵌套定义的类。内部类本身的结构同普通类没什么区别，只不过是定义的位置是在另一个类的内部。内部类可以被修饰成为static属性，这在普通类是不行的。
代码示例如下：
public class Outer { //定义外部类Outer
static class Inner{ //定义内部类Inner
static int x = 0; //定义内部类static成员变量x
static void test(){ //定义内部类static成员方法test
System.out.println("test");
}
}
public static void main(String[] args) {
System.out.println(Outer.Inner.x);//打印内部类Inner的static变量x
Outer.Inner.test(); //打印内部类Inner的static方法test
}
}
结果如下：
0
test
定义的内部类同样可以被外部引用。内部类可以只定义类体，没有名称，这就是匿名内部类。匿名内部类没有类名，直接用new关键字创建对象，后面｛｝部分为匿名内部类的类体。
类名（接口名） 对象名 = new 类名（接口名）｛
接口中必须要实现的方法
｝；
六、包
关键字：package，用法：package PackageName包名是当前源文件下的目录名称。在编写程序时，报名必须写在类文件的最上面。
使用包：
1. 包名加类名
2. Import 导入
3. 静态导入（在导入的对象前加static修饰符）使用了静态导入后，可以直接使用导入类中的变量，不必要采用“类名+.“的方式了。
2012年11.3日写于寝室
by：明明很爱（xiao金刚）
时间到了，睡觉去了，早上还有课，下午还要去兼职，都不让人活了。大家慢慢吸收，不回答的回帖，等俺慢慢为你解答。
