黑马程序员--面向对象

------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

面向对象

面向对象概念
面向对象是相对面向过程而言，面向对象和面向过程都是一种思想。
面向过程：强调的是功能行为

面向对象的特点
是一种符合人们思考习惯的思想，可以将复杂的事情简单化，将程序员从执行者转换成了指挥者。

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

面向对象三大特性：

封装
封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
好处：
    1.将变化隔离。
    2.便于使用。
    3.提高重用性。
    4.提高安全性。
封装原则：
   1.将不需要对外提供的内容都隐藏起来。
   2.把属性都隐藏，提供公共方法对其访问。如，getXXX，setXXX。

class Person{
 //private：私有，是一个权限修饰符，用于修饰
 //不希望别人直接访问赋值，需要通过私有化把属性进行隐藏
 private int age ;

 //通过提供set、get公共方法对其访问
 public void setAge( int a){
 //在set方法内可以对属性的赋值进行限制
 if (a > 0 && a < 130){
 age = a;
 } else
 System.out .println("错误的数据" );
 }

 public int getAge(){
 return age ;
 }

 void speak(){
 System.out .println("age = " + age);
 }
 }

 class PersonDemo{
 public static void main(String[] args){
 Person p = new Person();
 //通过其他方式访问
 p.setAge(20);
 p.speak();
 //赋值不合法，set方法就不允许成功赋值
 p.setAge(-20);
 }
 }

二，继承
    通过extends关键字让类与类之间产生继承关系。
    多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行
    为，只要继承那个类即可。多个类可以称为子类，单独这个类称为父类或者超类。
  好处：
     继承的出现提高了代码的复用性。
     继承的出现让类与类之间产生了关系，提供了多态的前提。
     Java只支持单继承，不支持多继承。
     一个类只能有一个父类，不可以有多个父类。
   原因：
     因为多继承容易出现问题。两个父类中有相同的方法，子类到底要执行哪一个是不确定的。

class Person{
 String name;
 int age ;
 }

 class Student extends Person{
 void study(){
 System.out.println("student study..." + age);
 }
 }

 class Worker extends Person{
 void work(){
 System.out.println("worker work..." + age);
 }
 }

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

 Worker w = new Worker();
 w. name = "lisi" ;

 w. age = 30;

 w.work();

 }

 }

三，多态
多态性简单说就是一个对象对应着不同类型。
 体现：
父类或者接口的引用指向或者接收自己的子类对象。
作用：
多态的存在提高了程序的扩展性和后期可维护性。

前提：
1.需要存在继承或者实现关系。
2.需要有覆盖操作。
好处：
提高了代码的扩展性，前期定义的代码可以使用后期的内容。
 弊端：
前期定义的内容不能使用（调用）后期子类的特有内容。

 abstractvoideat();
 }

 classDogextendsAnimal{
 voideat(){
 System.out.println("啃骨头");
 }
 voidlookHome(){
System.out.println("看家");
 }
 }
classCatextendsAnimal{
 voideat(){
 System.out.println("吃鱼");
 }
 voidcatchMouse(){
 System.out.println("抓老鼠");
 }
 }
 classPigextendsAnimal{
 voideat(){
 System.out.println("饲料");
 }
 voidgongdi(){
 System.out.println("拱地");
 }
 }
 classDuoTaiDemo{
 publicstaticvoidmain(String[]args){
 Catc=newCat();
 Dogd=newDog();

 method(c);
 method(d);
 method(newPig());
}

 publicstaticvoidmethod(Animala){
 a.eat();
 }
 }

下面说一说接口与一些关键字：

接口
当一个抽象类中的方法都是抽象的时候，这时可以将该抽象类用另一种形式定义和表示，就是接口。
格式：interface{}
接口中的成员修饰符是固定的：
成员常量：publicstaticfinal
成员函数：publicabstract
由此得出结论，接口中的成员都是公共的权限。
接口是对外暴露的规则。
接口是程序的功能扩展。
注意：
1、虽然抽象类中的全局变量和抽象方法的修饰符都可以不用写，但是这样阅读性很差。所以，最好写上。
2、类与类之间是继承关系，类与接口直接是实现关系。
3、接口不可以实例化，能由实现了接口并覆盖了接口中所有的抽象方法的子类实例化。否则，这个子类就是一个抽象类。

interface Demo{
 public static final int NUM = 4;
 public abstract void show1();
 public abstract void show2();
 }

 class DemoImpl implements /*实现*/Demo{
 public void show1(){}
 public void show2(){}
 }

 class InterfaceDemo{
 public static void main(String[] args){
 DemoImpl d = new DemoImpl();
 System.out.println(d.NUM);
 System.out.println(DemoImpl.NUM);
 System.out.println(Demo.NUM);
 }
 }

static 关键：
1，被static修饰的成员变量，被所有对象所共享。
2，静态随着类的加载而加载，随着类的消失而消失。
3，优先于对象存在。
4，静态成员可以直接被类名所调用。




static的使用注意事项。
1，静态方法只能调用静态成员，不能调用非静态成员。
非静态方法可以调用静态成员，也可以调用非静态成员。


2，在静态方法中不允许出现this，super关键字。
this代表对象，而静态方法执行时还没有对象呢！


3，主函数是静态的。


静态是有访问局限性的，只能访问静态的内容。 




静态成员变量和非静态成员变量的区别？


1，
非静态成员变量又称为实例变量。
静态成员变量又称为类变量。


2，
非静态成员变量，随着对象的创建而存在，随着对象的消失而消失。
静态成员变量，随着类的加载而存在，随着类的消失而消失。


3，
非静态变量存在于对象堆内存中。
静态变量存在于方法区中。


4，
非静态变量只能被对象所调用。
静态变量可以被类名调用，也可以被对象调用。


--------------------------------------------------------
this:代表的是一个对象。
代表哪个对象呢？
哪个对象调用this所在的函数，this就代表哪个对象。
this就是当前对象的一个引用。


this:表现形式一：当局部变量和成员变量同名的时候，可以用this来区分。


:表现形式二：构造函数之间的调用可以使用this关键字，后面跟上小括号，指定具体的实参即可明确要调用的构造函数。
特殊情况：注意：调用本类中构造函数的this语句必须定义在构造函数的第一行
因为初始化动作要先完成。 


------------------------------------------------------------
final关键字的特点：
1,final是一个修饰符，既可以修饰类，又可以修饰方法，还可以修饰变量。
2,final修饰的类不可以被继承。
3,final修饰的方法不可以被覆盖。
4,final修饰的变量是一个常量，只能赋值一次。
为了将固定的一些数据方便使用，会给这些起一个容易阅读的名称，
为了防止名称存储的数据改变。用final修饰。
一般为final修饰的变量名称都是大写字母组成，如果有多个单词，
每个单词之间用下划线分隔。