面向对象

面向过程：若使用面向过程的思维考虑问题，考虑的是过程和步骤。

Think how to do!

面向对象：考虑的是有几个对象，对象直接如何访问这些对象能够干什么

Thing what to do!

基本概念：

对象：一切皆对象。在JAVA的眼里，无论什么都是对象。

对象的组成：

属性（成员变量）：名词

行为（方法）：动词

类：对象的模板。具有相同属性和行为的一组对象的集合。

对象和类的区分：对象是具体存在的，而类是抽象的概念。

在JAVA中先创建类，再通过类创建具体的对象。

注意：在JAVA中同一个文件中只有一个类是public类型的，main方法所在类是public。

构造方法（构造器、构造函数）

最大的作用就是用来创建对象，还可以用来初始化成员变量。
构造方法是一种特殊的方法

a) 与类同名

b) 无返回值，边void都没有

c) 每一个类都有一个隐式的构造方法，隐式的构造方法没有参数，没有方法体。

d) 如果我们要手动的添加一个显示的构造方法，那么隐式的就不存在了

e) 构造方法只能和new关键字一起来创建对象，不能调用。

　　　public Person{

String name;

public Pseson(){ //隐式的构造方法，JAVA会自动创建

}

public Person(String name){ //显式的构造方法

this.name = name;

}

面向对象如何分析：

1先找出有几个对象

2 通过对象找出有几个类

3 找出每个类有哪些属性和方法

4 调用方法实现功能

//TOM猫抓住了老鼠JACKY,JACKY

public class Test{
    public static void main(String args[]){
    　　Cat tom = new Cat("tom");    
    　　Mouse jacky = new Mouse("jacky");
    　　tom.catchMouse(jacky);
     }
}

class Cat{
    String name;
    public Cat(String name){
        this.name = name;
    }
    
    public void catchMouse(Mouse m){
        m.cry();
    }
    
}

class Mouse{
    String name;
    public Mouse(String name){
        this.name = name;
    }
    public void cry(){
        System.out.println(name+" is crying!");
    }
}

//坦克发射炮弹

发射炮弹的方法应该是炮弹的方法。

专家模式：方法改变谁的状态，方法就属于谁

状态：属性（成员变量）的值

改变对象的状态其实就是改变成员变量的值。

JAVA中内存的分区：

Code segment:代码区用来存放字节码

Heap segment:堆区存放对象（可以保存大数据量内容，执行速度快）

Stack segment:栈区放局部变量（保存小数据量的内容，执行速度慢）

Static segment: 静态区（属于栈区中的一块特殊区域），放静态的变量和字符串常量。静态区中内容不能重复。

引用数据类型（类、数组等）

基本的数据类型的变量中保存真实的值。

引用的数据类型的变量保存的不是真实的对象，而是保存在堆中的内存的地址，通过地址可以找到在堆中的内容，所以变量不是对象，而是对象的引用。

成员变量初始化问题：

JAVA中成员变量问题会默认初始化。

数值类型：0 char: 空字符布尔类型：false

引用数据类型；null值（小写）

null含义：代表一个引用没有指向任何的对象，换句话说这个引用没有任何对象的内存地址

JAVA有垃圾回收机制，我们知道C++里申请了内存，必须动态释放。JAVA中有垃圾回收机制可以自动回收JAVA中无用的内存，什么是无用内存？就是一个对象没有引用指向的时候，这个对象就是垃圾。垃圾回收机制可以把垃圾马上回收。

构造方法的另外一个作用：初始化成员变量

成员变量和局部变量同名问题

this指针：每个对象都有一个this 指针，相当于当前对象的引用。

static关键字

加上statict的变量称之为静态变量（类变量）

加上statict的变量称之为静态方法（类方法）

类变量问题：

　　static segment中数据不能重复。所有的对象共享其数据，一个对象对它修改，其它的对象也相应修改。既然所有的对象共享它，也就是说这个变量跟对象没有任何关系的，所以称之为类变量，可以使用类名.变量的方式来调用。

类方法：

不需要创建对象，直接用类名.方法名调用。

public class Test{
       public static void main(String args[]){
    　　　　　　Person p1 = new Person(18);
    　　　　　　Person p2 = new Person(20);
    　　　　　　System.out.println(p1.age);
    　　　　　　System.out.println(p2.age);
        }
}
class Person{
        static int age;
        public Person(int age){
   　　　　 this.age = age;
        }
}

注意：静态方法中只能访问静态的成员变量。

非静态方法既可以访问静态变量，也可以访问非静态变量。

Main方法为什么是static 的？

Main方法是程序的入口，在它执行之前不可能有任何对象被创建，JVM需要调用main方法只能是static的。

Package包

JAVA是开源的，世界上所有的人编写的JAVA代码放到互联网共享，有一个要求，每个人的名称要是唯一的。

JAVA的包机制就是用不同的文件夹区分不同的类。

Package com.ch.nanchang.zjw.Test;

JAVA类的全名是；包名+类名

Package指定类的命名。

Import 导包，省略类的包名，直接使用用simpleName.

JAVA中常用的包：

Java.lang包，常用的基础类，不需要导包

Java.io包，输入输出流

Java.uitl 工具类

Java.net 网络编程

JAVA的访问修饰符：

private（私有）：只能在类的内部使用

default(默认)；在一个包下所有的类之间都可以使用

　　　protected(受保护)：继承中可以互相调用，两个类中如果在同一个包下，如果是继承关系，可以调用

public(公共的)：到处都可以使用

面向对象的三基本特征：

1、继承

代码复用，屏蔽细节

2、继承

代码复用，功能上的扩展

3、多态(动态绑定、池绑定)

继承是指对象之间的一种关系！

如果说一句话说得通：什么是一种什么？

在JAVA中用extends关键字表示继承关系，当子类继承了一个父类的时候，子类自动拥有父类的所有成员。

注意：JAVA是单继承，通俗讲就是一个儿子只一个亲爹。

方法的重写/覆盖（override）:

方法的重写是发生在继承关系中，父类中被重写的方法与子类中的方法必须具有相同的方法名、返回值类型、参数列表。子类中的方法的访问修饰符不能有比父类更严格的访问修饰符。

class Animal{
       String name;
       public void enjoy(){
    　　　　System.out.println("animal is enjoy");
       }
}

class Cat extends Animal{
        String name;
        String fur;
        public void enjoy(){
    　　　　System.out.println("cat is enjoy");
        }
}

方法的重载（overload）

　　定义：根据调用方法的时候，传入的实际参数来决定到底该载入哪个方法。

　发生在同一个类中，重载的方法和被重载的方法拥有相同的方法名，必须拥有不同的参数列表，返回值类型可以不一样。

public class Test{
         public static void main(String args[]){
                   System.out.println(Sum.add(5,6));
                   System.out.println(Sum.add(5,6,7));
         }
}

class Sum{
         public static int add(int a,int b){
                  return a+b;
         }
         public static int add(int a,int b,int c){
                   return a+b+c;
         }

}

Super关键字：

　　相当于当前父类对象的引用。

每一个子类的对象中都有一个父类的对象，因为子类自动拥有所有父类的成员，如果子类中没有父类的对象的引用的话，就不能实现上述标准了。

Java在创建子类对象的时候，先创建父类的对象，再创建子类的对象。

Super三种情况要用：

　　１、当子类的成员变量和父的成员变量同名时，需要访问父类的成员变量。Super.父类的成员名

　　２、重写的过程中，子类重写的方法需要调用父类被调用的方法的时候。Super.方法名

　　３、如果父类中没有无参的构造方法是不能成功创建对象的，需要在子类构造方法中手动调用父类的构造方法。

　　　　a) 创建父类的对象再创建子类的对象

　　　　b) JAVA通过构造方法创建对象

　　　　c) 先要调用父类的构造方法，再调用子类的构造方法

　　　　d) JAVA默认调用父类无参数的构造方法

　　　　e) 给父类提供了有参数的构造方法，隐式的构造方法就不存在了

public class Test{
         public static void main(String args[]){
                  Cat c = new Cat()；
       }
}

class Animal{
　　public Animal(int num){
　　}
}
class Cat extends Animal{
　　public Cat(){
　　　　　　super(10);
　　　　　　System.out.println("1111111");
　　}
}

注意：super在子类构造方法第一行！！

对象转型：

　　向上转型：父类引用指向子类对象。

　　　　注意：当父类引用指向子类对象的时候，不能使用子类中多出来的成员！！

向下转型：强制类型转。

多态：动态绑定、池绑定

　　当程序执行的时候，根据传入的参数决定绑定的方法。

　　　１. 有继承

2.要有方法的重写

3. 要有父类的引用指向子类的对象

public class Test{
       public static void main(String args[]){
　　　　　　　　Person p1 = new Person();
　　　　　　　　Dog dog = new Dog();
　　　　　　　　Cat cat  = new Cat(); 
　　　　　　　　p1.playWithAnimal(dog);    
　　　　}
}

class Person{
　　　　public void playWithAnimal(Animal a){
　　　　　　　　a.enjoy();
　　　　}
}

class Animal{
　　　　public void enjoy(){
　　            System.out.println("Animal is enjoy");
       }
}

class Cat extends Animal{
      public void enjoy(){
             System.out.println("Cat is enjoy");
      }
}

class Dog extends Animal{
      public void enjoy(){
             System.out.println("Dog is enjoy");
      }
}

Objiect类：

JAVA所有类的根基类,object类中所有的方法其他类都拥有。

１. toString()方法

　　１. System.out.println();

　　２. 字符串连接符

注：控制台只能显示字符串，所以打印之前要先转换成字符串再打印。

2.euqals()方法

“==”比较的是栈区的内容，要比较对象用equals方法，重写equals方法一定要重写hashCode()方法

JAVA的类是我们自己创建的，与这个相关的规则也需要我们自己去指定，比较是否相等的规则，比较大小的规则。

public class Test{
       public static void main(String args[]){
               Person p1 = new Person("Tom",20);
               Person p2 = new Person("Tom",30);
               System.out.println(p1.equals(p2));
       }
}

class Person{
　　　　String name;
       int age;
　　　　public Person(String name,int age){
               this.name = name;
               this.age = age;
       }

       public String toString(){
              return "name: "+name+" age:"+age;
       }        
       public boolean equals(Object obj){
              Person p = (Person)obj;
              if(this.name.equals(p.name)&&this.age==p.age){
                     return true;
              }else
             　　     return false;
              }

       public int hashCode(){
              return this.name.hashCode();
       }
}

　　内存中分成许多区域，每个区域的的编码叫哈希码。（哈希码是无序的）

　　相等的对象一定具有相等的hash码。

　　具有相同hash码的两个对象一定相等（错）

final关键字；

　加在成员变量上，表示常量（常量名称每一个字母大写）。

　加在类上 ,类不能被继承

　加在方法上,方法不能被重写,默认都是final的。但final类的方法被可以继承。

abstract关键字(抽象的)

　类上，不能实例化（不能用来创建对象）

　如果有一个类就是用来被继承的，比如说多态，父类引用指向子类对象时候，父类不需要实例化，这时可在指定这个类是抽象的。

　抽象的方法就是用来重写的，不需要方法体。

　　注意：具有抽象方法的类一定是抽象类，抽象类中可以有非抽象的方法。

public class Test{
       public static void main(String args[]){
    　　　　　Person p1 = new Person();
    　　　　　Cat cat = new Cat();
    　　　　　p1.playWithAnimal(cat)；    
      　}
}

class Person{
      public void playWithAnimal(Animal a){
     　　　　a.enjoy();
      }
}

abstract class Animal{
         public abstract void enjoy();
         public void A(){}
}

class Dog extends Animal{
      public void enjoy(){
    　　　    System.out.println("dog is enjoy");
       }
}

class Cat extends Animal{
       public void enjoy(){
             System.out.println("Cat is enjoy!");
        }
}

接口（interface）规范、标准

　　接口是一种特殊的抽象类 ,接口只能有抽象方法和常量。

　　常量默认都是public static final

　　方法默认都是public abstact

接口称之为类实现接口，方法也称之为实现。

接口可以有多个，父类只能有一个，类与接口叫实现，接口可以多继承。

public class Test{
       public static void main(String args[]){
　　　　　　　　Bmw bmw = new Bmw();
　　　　　　　　bmw.run();
　　　　　　　　System.out.println(bmw.num);
　　　　}
}

interface A{
　　public void abc();
}

interface B{
　　public void B();
}

interface Car extends A{
　　int num = 10;  //默认是public static final num = 10;
　　public void run();//默认是public abstarct void run();
　　public void stop();
}

class Bmw implements Car,B{
      public void run(){
　　           System.out.println("Bmw is running");
      }
      public void stop(){
             System.out.println("Bmw is stopping");
      }
      public void abc(){
             System.out.println("abc");
      }
      public void B(){}
}

posted @ 2013-02-24 14:40 bod08zengjianwei 阅读(136) 评论(0) 收藏举报

刷新页面返回顶部

bod08zengjianwei

面向对象

公告