黑马程序员_面向对象

<span style="font-family: Simsun;font-size:14px;">------- </span><a target=_blank href="http://www.itheima.com/" target="blank" style="font-family: Simsun;font-size:14px;">android培训</a><span style="font-family: Simsun;font-size:14px;">、</span><a target=_blank href="http://www.itheima.com/" target="blank" style="font-family: Simsun;font-size:14px;">java培训</a><span style="font-family: Simsun;font-size:14px;">、期待与您交流！ ---------- </span>

面向对象

怎么理解面向对象？

        面向对象是当今主流的一种程序设计理念和设计规范，它取代了早期的"结构化"过程设计开发技术，主张一切皆为对象，程序以人的思维模式去解决问题。

        面向对像的程序是由类组成的，每个类包含对用户公开的特定功能部分和隐藏的实现部分。传统的结构化程序设计通过设计一系列的过程（即算法）来求解问题。这一些过程一旦被确定，就要开始考考虑存储数据的方式，这就明确的表述了程序员的工作方式。

但面相对像却调换了这个顺序，它不必关心数据对象的具体实现，只要能满足用户的需求即可。

面向对象有三个最基本的特性，即：封装，继承，多态。

封装（Encapsulation）

封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
好处：
①将变化隔离。
②便于使用。
③提高重用性。
④提高安全性。

封装原则：
①将不需要对外提供的内容都隐藏起来。
②把属性都隐藏，提供公共方法对其访问。

 

示例：

Person.java

/*

人：

属性：年龄

行为：说话

*/

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);

      }

} 

注意：

1、私有仅仅是封装的一种体现而已。

2、private关键字：是一个权限修饰符，用于修饰成员(成员变量和成员函数)，被私有化的成员只在本类中有效。

常用场景之一：将成员变量私有化，对外提供对应的set、get方法对其进行访问，提高对数据访问的安全性。

继承(inheritance)
1.提高了代码的复用性
2.让类与类之间产生了关系，有了这个关系，才有了多态的特性。必须是类与类之间有所属关系才可以使用继承。所属关系 is a。

java只支持单继承，不支持多继承，多继承容易带来安全隐患：当多个父类中定义了多个相同功能，当功能内容不相同时，不确定调用了父类的哪一个。但是java可以通过多实现来实现。

多态(polymorphism)
：可以理解为事物存在的多种体现形态。
父类的引用指向子类的对象。


1.多态的体现
  父类的引用指向子类的对象，父类的引用接收子类的对象。
2.多态的前提
   类与类之间必须是继承或者实现的关系。通常还有一个前提 就是覆盖
3.多态的好处
  大大的提高了程序的扩展性
4.多态的弊端
  提高了扩展性，但是只能使用父类的引用访问父类中的成员。
5.多态的应用
6.多态中成员的特点
  a)非静态成员函数：在编译时期，参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有编译失败。
             在运行时期，参阅对象所属的类中是否有调用的方法。
             总结，成员函数在多态调用的时候，编译看左边父类，运行看右边子类。
  b)成员变量：无论编译和运行，都参考左边父类。
  c)静态成员函数：无论编译和运行都参考左边父类。


如何使用子类特有方法：多态转型。
Animal  a=new Cat();//类型提升，向上转型。
a.eat();//父类的共有方法。


如果要调用cat的特有方法的时候 ，就必须将父类的引用转成子类的类型，但是不能将父类对象转成子类类型，转换的是父类的引用，(就是父类的变量)
Cat c=(Cat)a;
c.catchmouse();//子类的特有方法。


示例：


/*
 * 基础班学生：
 *   学习 、睡觉
 * 高级班学生
 *   学习、睡觉
 * 
 */


abstract class Student {

public abstract  void study();
public static void sleeps(){
System.out.print("睡觉");
}
}




class jichu extends Student{
public void study()
{
System.out.print("学习基础");
}
public static void sleeps(){
System.out.print("站着");
}
}


class gaoji extends Student{
public void study()
{
System.out.print("学习高级");
}
public static void sleeps(){
System.out.print("趴着");
}
}


class DoStudent
{
public void dosome(Student stu)
{
stu.study();
stu.sleeps();
}
}
public class duotai {
public static void main(String[] args) {
DoStudent ds=new DoStudent();
ds.dosome(new jichu());//传的是子类对象 
ds.dosome(new gaoji());


}
}

--内部类访问特点：

1，||内部类可以直接访问外部类中的成员。

2，||外部类要访问内部类，必须建立内部类的对象。

一把用于类的设计。

分析事物时，发现该事物描述中还有事物，而且这个事物还在访问被描述事物的内容。

这时就是还有的事物定义成内部类来描述。

为什么内部类能直接访问外部类中成员呢？

那是因为内部类持有了外部类的引用。 外部类名.this

内部类可以存放在局部位置上。

内部类在局部位置上只能访问局部中被final修饰的局部变量。

        

内部类的访问规则：

①内部类可以直接访问外部类中的成员，包括私有。

       为什么内部类能直接访问外部类中成员呢？

那是因为内部类持有了外部类的引用格式：外部类名.this

②外部类要访问内部类，必须建立内部类对象。

System.out.println(“inner:”+Outer.this.x);

      小格式：Outer.Inner int = new Outer().new Inner();直接访问内部类中的成员。

访问格式：

①当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。

可以直接建立内部对象。

格式：

外部类名.内部类名 变量名 = 外部类对象.内部类对象；

Outer.Inner in = new Outer().new Inner();

②当内部类在成员位置上，就可以被成员修饰符所修饰。

比如，private：将内部类在外部类中进行封装。

Static：内部类就具备static的特性。

当内部类被static修饰后，只能直接访问外部类中的static成员。出现了访问局限。

在外部类其他类中，如果直接访问static内部类的非静态成员呢？

New Out.Inner().function();

在外部其他类中，如何直接访问static内部类的静态成员呢？

Outer.Inner.function();

注意：当内部类中定义了静态成员，该内部类必须是static的。

              当外部类中的静态方法访问内部类时，内部类也必须是staitic的。

 静态不能修饰局部变量。

使用时机：当描述事物时，事物的内部还有事物，该事物用内部类来描述。

因为内部事务在使用外部事物的内容。

class Outer{   

private static int num = 31;

class Inner  // 内部类。

       {      void show(){

                     System.out.println("showrun..."+num);

              }/*static void function() //如果内部类中定义了静态成员，该内部类也必须是静态的。

              {      System.out.println("functionrun ...."+num);

              }*/

       }publicvoid method(){  

Inner in = new Inner();

              in.show();

       }

}

class InnerClassDemo

{      publicstatic void main(String[] args){

//            Outer out = new Outer();

//            out.method();//直接访问外部类中的内部类中的成员。

//            Outer.Inner in = new Outer().new Inner();

//            in.show();//如果内部类是静态的。 相当于一个外部类

//            Outer.Inner in = new Outer.Inner();

//            in.show();//如果内部类是静态的，成员是静态的。

//            Outer.Inner.function();

       }

}

设计模式： （解决问题的模式，方案。可有自己的模式，GOF拥有23种通用设计模式。）多种设计模式的结合便是框架的构建。

定义：解决某一问题最行之有效的方法。

单例设计模式：解决一个类在内存只存在一个对象。

目标：保证对象的唯一！

1，为了避免其他程序过多建立该类对象，先禁止其他程序建立该类对象。

2，还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象。

3，为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。

代码体现过程：

1，将构造函数私有化

2，在类中创建一个本类对象。

3，提供一个方法可以获取到该对象。

 

-----------对于事物该怎么描述还怎么描述。当需要将该事物的对象保证在内存中唯一时，就将以上的三步加即可。----------

Class Single {

private intnum;  //所有变量

public voidsetNum(int num){

this.num=num;

}                                           /        //设置 num

public int getNum(){

return num;

}                                                   //获取改变的变量 num

private single(){}                                             //②私有构造函数，使得类外不可用该类创建对象。

private staticSingle s=new Single();                //①私有并静态的本类对象

public static singlegetInstance(){

return s;

}                                                                     //③建立一个公有且静态的返回本类对象的方法。

}

Class SingleDome{

public static voidmain(String[] args){

//Single ss=Single.getInstance();

 

}

}       (考虑私有和静态的存在时机！很重要！)

上面为饿汉式，下面是懒汉式 区别在于对象的建立先后（对象是方法被调用，才初始化）。

Single s=null;     //没有对象的建立；

Public static SinglegetInstance(){

If(s==null)

S=new Single();/ /为空，则建立。

Return s;

}

记录原则：定义单例，建议使用饿汉式。

关于锁在懒汉式间的使用：

Public static SinglegetInstance(){

If (s==null){

Synchronized(Single.class){           //访问锁

If(s==null)

S=new Single();

}

}

return s;

} 

<span style="font-family: Simsun;font-size:14px;">------- </span><a target=_blank href="http://www.itheima.com/" target="blank" style="font-family: Simsun;font-size:14px;">android培训</a><span style="font-family: Simsun;font-size:14px;">、</span><a target=_blank href="http://www.itheima.com/" target="blank" style="font-family: Simsun;font-size:14px;">java培训</a><span style="font-family: Simsun;font-size:14px;">、期待与您交流！ ---------- </span>