2013年8月21日、面向对象的大纲||继承||父类、子类

回家的感觉真好、没有那么强烈的急迫感、和压抑的感觉、家人是你最好的、最坚强的护盾。

欢迎我回家、 早安、中国、

————————————————————————————————————————————

函数：




数组：




---------------------


面向对象：


1，面向对象和面向过程思想。

面向对象强调的是对象实例。
面向过程强调的是动作。
对象将动作进行封装。


在问题领域中，我们先去找的都是涉及的对象，
然后分析对象的属性和行为。




2，面向对象的特点。
1，是一种常见思想。
2，复杂变简单。
3，执行者变指挥者。
举例：面试的例子。




3，类与对象的关系。
类：就是对事物的描述，其实类就是将对象共性的内容进行抽取。
对象：就是该类事物实实在在存在个体，在java中通过new来完成创建的，
堆内存的对象主要用于封装对象中的特有数据。




4，类中的成员：
成员变量：事物的属性，
成员函数：事物的行为。


成员变量和局部变量的区别？
答：

如何使用成员，只要建立该类对象，并通过 "对象.对象成员" 就可以完成调用


5，封装。
隐藏实现细节，并对外提供公共的访问方式。


函数或者类都是一个封装体。


特点：
1，隔离的变量。
2，便于使用。
3，提高复用。
4，提高安全性。


举例：机箱的例子




体现之一：私有。


私有在源代码中的使用就是在本类中有效。

通常会将成员变量xxx私有化，并对外提供对应的setXxx getXxx方法对其进行访问。
其实目的就是成员变量访问进行控制。 让成员的访问具备可控性，提高了程序的健壮性。


私有仅仅是封装的体现形式之一而已。


自定义一个Person类。动手。


6，构造函数。
写法特点：
1，函数名和类名相同。
2，不需要定义返回值类型
3，没有具体的返回值。但是有return语句，用于结束构造函数。


使用特点：
1，定义类中，有默认的空参数构造函数。如果已经自定义，那么默认就没有了。
2，构造函数在类有多个，是重载形式体现出来的。

构造函数的作用：
用于给对象进行针对性的初始化。






构造函数和一般函数的区别？
1，
2，
3，


什么时候使用构造函数呢？
当对象创建时就需要一些内容(数据和行为)，那么这些内容都定义在构造函数中。

7，this关键字.
this：代表的是对象。哪个对象调用了this所在的函数，this就代表哪个对象。 

用法体现
1，当成员变量和局部变量同名时，可以用this区别。
2，当构造函数中调用本类其他构造函数时，可以用this完成。 this(实际参数);
这种调用必须定义在构造函数的第一行。初始化动作先完成。


应用：只要在定义功能时，用到了本类对象，那么就使用this来表示。




8，static关键字：

特点：
1，修饰成员。，
2，随着类加载，随着类消失。
3，优先于对象。
4，用类名直接访问 


使用注意事项:
1，静态方法只能访问静态，静态有访问局限性。
2，静态方法中不能有this super关键字。
3，主函数是静态的。


静态变量和成员变量的区别？
1，
2，
3，
4，



什么时候使用静态？
1，当成员变量的数据各个对象都相同时，可以用static修饰，让多个对象共享。
2，函数如果访问了特有数据(非静态成员变量),该函数是非静态的。
  函数如果没有访问特有数据，那么该函数就可以静态修饰。





如果类中的功能都是静态的，那么该类创建对象是没有意义的，所以构造函数需要私有化。






9，代码块。
1，局部代码快。
对局部变量的生命周期进行控制。
2，构造代码块。
对所有对象进行初始化。
3，静态代码块。
对类进行初始化。




10，单例设计模式：
1，解决的问题：保证类在内存的对象唯一性。
2，思路：
3，步骤：
4，两种方式的区别？懒汉式(延迟加载方式)，饿汉式


设计的内存图要会画！必须的。

——————————————————————————————————————————————————

继承

/*
继承的好处：
1，提高了代码的复用性。
2，让类与类之间产生了关系，给第三个特征多态提供了前提.






java中支持单继承。不直接支持多继承，但对C++中的多继承机制进行改良。


单继承：一个子类只能有一个直接父类。


多继承：一个子类可以有多个直接父类(java中不允许,进行改良)
不直接支持，因为多个父类中有相同成员，会产生调用不确定性。
在java中是通过"多实现"的方式来体现。




java支持多层(多重)继承。


C继承B，B继承A。
就会出现继承体系。


当要使用一个继承体系时，
1，查看该体系中的顶层类，了解该体系的基本功能。
2，创建体系中的最子类对象，完成功能的使用。 


class Demo
{
void show1(){}
}




class DemoA extends Demo
{
// void show1(){}
void show2(){}
}
class DemoB extends Demo
{
// void show1(){}
void show3(){}
}


什么时候定义继承呢？


当类与类之间存在着所属关系的时候，就定义继承。xxx是yyy中的一种。 xxx extends yyy


所属关系： is a 关系。








*/
/*
class A
{
void show()
{
System.out.println("a");
}
}
class B 
{
void show()
{
System.out.println("b");
}
}
class C extends A,B
{
}
new C().show();
*/
class Person
{
String name;
int age;
}






class Student extends/*继承*/ Person
{
// String name;
// int age;
void study()
{
System.out.println(name+"...student study.."+age);
}
}




class Worker extends Person
{
// String name;
// int age;
void work()
{
System.out.println("worker work");
}
}




class ExtendsDemo 
{
public static void main(String[] args) 
{
Student s = new Student();
s.name= "zhangsan";
s.age = 22;
s.study();
}
}

————————————————————————————————————————————————

//成员函数。
/*
当子父类中出现成员函数一模一样的情况，会运行子类的函数。
这种现象，称为覆盖操作。这时函数在子父类中的特性。
函数两个特性：
1，重载。同一个类中。overload
2，覆盖。子类中。覆盖也称为重写，覆写。override
——————————————————————————面试题、
覆盖注意事项：
1，子类方法覆盖父类方法时，子类权限必须要大于等于父类的权限。 
2，静态只能覆盖静态，或被静态覆盖。






*/
class Fu
{
public static  void show()
{
System.out.println("fu show run");
}
}


class  Zi extends Fu
{
public static void show()
{
System.out.println("Zi show run");
}
}


class ExtendsDemo3 
{
public static void main(String[] args) 
{
// Zi z = new Zi();
// z.show();
NewPhone p = new NewPhone();
p.show();
p.call();
}
}


/*
什么时候使用覆盖操作?


当对一个类进行子类的扩展时，子类需要保留父类的功能声明，
但是要定义子类中该功能的特有内容时，就使用覆盖操作完成.


*/
class honeP
{
void call()
{}
void show()
{
System.out.println("number");
}
}


class NewPhone extends Phone
{
void show()
{
System.out.println("name");
System.out.println("pic");
super.show();
}
}