比如说，我在A类中创建了一个对象数组。想在B类中去使用这个A类中的数组。那么有两种方式
 以下创建的数组都是类类型的数组
 我觉得类类型数组的好处可以给数组中的每一个元素创建多个标签。并且可以对多个标签进行不同的操作
 1 继承
 直接让B类去继承这个A类，那么在B类中就可以对这个数组进行操作
 如下图
 这是Child类，有个数组childs。长度是40；
 
 下面这个是Damo1类，直接继承上面这个Child类，那么久可以直接对这个数组进行操作，这个操作时合并数组。在Damo1中创建一个数组。将Child中的数组合并进去。
 
 上面是继承方式，还有一种方式
 
如下图所示
 我在Td中创建一个数组。是类类型的数组，叫tt
 
 下面这个是在Damo1类中，先创建一个Td类中的对象JJTd，然后也创建一个Td类型的数组，叫ggDamo1s。让这个ggDamo1s
 等于Td中的数组、所以就可以在Damo1中对tt数组进行操作
 
 
当然，也有其他的解法。

#include<iostream>
using namespace std;
class point
{
private:
	int x;
	int y;
public:
	int getx()//如何引用私有类的成员
	{
		return x;
	}
	void setx(int xx)
	{
		 x = xx;
	}
	int gety()//如何引用私有类的成员
	{
		return y;
	}
	void sety(int yy)
	{
		y = yy;
	}
	void input()
	{
		cin >> x >> y;
	}
	void output()
	{
		cout << "(" << x << "," << y << ")" << endl;
	}
};
class line
{
private:
	point p1, p2;
public:
	void input()
	{
		p1.input();
		p2.input();
	}
	void output()
	{
		p1.output();
		p2.output();
	}
};
int main()
{
   line a;
	a.input();
	a.output();
	system("pause");
	return 0;
}

1、instanceof：用来测试左边对象是否是一个类：

　　int a = 1;
　　boolean flag= a instanceof Object;

        返回结果为true，代表a是一个类，否则不是类。



2、getclass()：
        比如：if(a.getClass()==String.getClass())

一、面向对象简述
 
面向对象是一种现在最为流行的程序设计方法，几乎现在的所有应用都以面向对象为主了，最早的面向对象的概念实际上是由IBM提出的，在70年代的Smaltalk语言之中进行了应用，后来根据面向对象的设计思路，才形成C++，而由C++产生了Java这门面向对象的编程语言。
 
但是在面向对象设计之前，广泛采用的是面向过程，面向过程只是针对于自己来解决问题。面向过程的操作是以程序的基本功能实现为主，实现之后就完成了，也不考虑修改的可能性，面向对象，更多的是要进行子模块化的设计，每一个模块都需要单独存在，并且可以被重复利用，所以，面向对象的开发更像是一个具备标准的开发模式。
 
在面向对象定义之中，也规定了一些基本的特征： 
 （1）封装：保护内部的操作不被破坏； 
 （2）继承：在原本的基础之上继续进行扩充； 
 （3）多态：在一个指定的范围之内进行概念的转换。
 
对于面向对象的开发来讲也分为三个过程：OOA（面向对象分析）、OOD（面向对象设计）、OOP（面向对象编程）。
 
二、类与对象的基本概念
 
类与对象时整个面向对象中最基础的组成单元。
 
类：是抽象的概念集合，表示的是一个共性的产物，类之中定义的是属性和行为（方法）； 
 对象：对象是一种个性的表示，表示一个独立的个体，每个对象拥有自己独立的属性，依靠属性来区分不同对象。
 
可以一句话来总结出类和对象的区别：类是对象的模板，对象是类的实例。类只有通过对象才可以使用，而在开发之中应该先产生类，之后再产生对象。类不能直接使用，对象是可以直接使用的。
 
三、类与对象的定义和使用
 
在Java中定义类，使用关键字class完成。语法如下：
 
class 类名称 {
         属性 (变量) ;
         行为 (方法) ;
}
 
范例：定义一个Person类
 
class Person {     // 类名称首字母大写
    String name ;
    int age ;
    public void tell() {        // 没有static
          System.out.println("姓名：" + name + "，年龄：" + age) ;
         }
}
 
类定义完成之后，肯定无法直接使用。如果要使用，必须依靠对象，那么由于类属于引用数据类型，所以对象的产生格式（两种格式）如下：
 
（1）格式一：声明并实例化对象
 
类名称 对象名称 = new 类名称 () ;
 
（2）格式二：先声明对象，然后实例化对象： 
 
类名称 对象名称 = null ;
对象名称 = new 类名称 () ;
 
引用数据类型与基本数据类型最大的不同在于：引用数据类型需要内存的分配和使用。所以，关键字new的主要功能就是分配内存空间，也就是说，只要使用引用数据类型，就要使用关键字new来分配内存空间。
 
当一个实例化对象产生之后，可以按照如下的方式进行类的操作： 
 对象.属性：表示调用类之中的属性； 
 对象.方法()：表示调用类之中的方法。
 
范例：使用对象操作类
 
package com.wz.classandobj;

class Person { 
    String name ;
    int age ;
    public void get() {
        System.out.println("姓名：" + name + "，年龄：" + age);
    }
}

public class TestDemo {
        public static void main(String args[]) {
            Person per = new Person() ;// 声明并实例化对象
            per.name = "张三" ;//操作属性内容
            per.age = 30 ;//操作属性内容
            per.get() ;//调用类中的get()方法
        }
}
 
运行结果：
 
姓名：张三，年龄：30
 
以上完成了一个类和对象的操作关系，下面换另外一个操作来观察一下：
 
package com.wz.classandobj;

class Person { 
    String name ;
    int age ;
    public void get() {
        System.out.println("姓名：" + name + "，年龄：" + age);
    }
}

public class TestDemo {
        public static void main(String args[]) {
            Person per = null;//声明对象
            per = new Person() ;//实例化对象
            per.name = "张三" ;//操作属性内容
            per.age = 30 ;//操作属性内容
            per.get() ;//调用类中的get()方法
        }
}
 
运行结果：
 
姓名：张三，年龄：30
 
那么，问题来了，以上两种不同的实例化方式有什么区别呢？ 
 我们从内存的角度分析。首先，给出两种内存空间的概念： 
 （1）堆内存：保存对象的属性内容。堆内存需要用new关键字来分配空间； 
 （2）栈内存：保存的是堆内存的地址（在这里为了分析方便，可以简单理解为栈内存保存的是对象的名字）。
 
 
任何情况下，只要看见关键字new，都表示要分配新的堆内存空间，一旦堆内存空间分配了，里面就会有类中定义的属性，并且属性内容都是其对应数据类型的默认值。
 
于是，上面两种对象实例化对象方式内存表示如下： 
 
 
两种方式的区别在于①②，第一种声明并实例化的方式实际就是①②组合在一起，而第二种先声明然后实例化是把①和②分步骤来。
 
另外，如果使用了没有实例化的对象，结果如何？ 
 如下：
 
package com.wz.classandobj;

class Person { 
    String name ;
    int age ;
    public void get() {
        System.out.println("姓名：" + name + "，年龄：" + age);
    }
}

public class TestDemo {
        public static void main(String args[]) {
            Person per = null;//声明对象
            //per = new Person() ;//实例化对象
            per.name = "张三" ;//操作属性内容
            per.age = 30 ;//操作属性内容
            per.get() ;//调用类中的get()方法
        }
}
 
运行结果：
 
Exception in thread "main" java.lang.NullPointerException
    at com.wz.classandobj.TestDemo.main(TestDemo.java:15)
 
此时，程序只声明了Person对象，但并没有实例化Person对象（只有了栈内存，并没有对应的堆内存空间），则程序在编译的时候不会出现任何的错误，但是在执行的时候出现了上面的错误信息。这个错误信息表示的是“NullPointerException（空指向异常）”，这种异常只要是应用数据类型都有可能出现。
 
四、对象引用传递初步分析
 
引用传递的精髓：同一块堆内存空间，可以同时被多个栈内存所指向，不同的栈可以修改同一块堆内存的内容。
 
下面通过若干个程序，以及程序的内存分配图，来进行代码的讲解。
 
我们来看一个范例：
 
class Person {     
         String name ;
         int age ;
         public void tell() {        
                   System.out.println("姓名：" + name + "，年龄：" + age) ;
         }
}
public class TestDemo {
         public static void main(String args[]) {
                   Person per1 = new Person() ;         // 声明并实例化对象
                   per1.name = "张三" ;
                   per1.age = 20 ;
                   Person per2 = per1 ;  // 引用传递
                   per2.name = "李四" ;
                   per1.tell() ;
         }
}
 
对应的内存分配图如下：
 
 
再来看另外一个：
 
class Person {
         String name ;
         int age ;
         public void tell() {
                   System.out.println("姓名：" + name + "，年龄：" + age) ;
         }
}
public class TestDemo {
         public static void main(String args[]) {
                   Person per1 = new Person() ;         // 声明并实例化对象
                   Person per2 = new Person() ;
                   per1.name = "张三" ;
                   per1.age = 20 ;
                   per2.name = "李四" ;
                   per2.age = 30 ;
                   per2 = per1 ;// 引用传递
                   per2.name = "王五" ;
                   per1.tell() ;
         }
}
 
对应的内存分配图如下： 
 
 
垃圾：指的是在程序开发之中没有任何对象所指向的一块堆内存空间，这块空间就成为垃圾，所有的垃圾将等待GC（垃圾收集器）不定期的进行回收与空间的释放。
 
未完待续。。。