3面向对象的基本思想

String name; int age; public void setName(String a){//set方法 name=a; } public void setAge(int b){ age=b; } public String getName(){ return name; } public int getAge(){ return age; } public void call(){ System.out.println("the name is:"+name+",age is"+age); } } 上面的代码中只是可以访问封装的内容，但是对属性的赋值还没有验 证，需要在set方法中加入验证，注意：一定是在set方法中进行验证。 如下： if(b>=0 && b<=150){ age=b; } else age=0; 此时就达到了实际中的要求了。
System.out.println("the name is:"+name+",age is"+age); } }
对象的比较：“==”与equals();方法的区别
“==”比较两个变量的值是否相等；equals是比较两个对象的内容是否 相等。 ==实例1： public class ForTest { public static void main(String args[]) { String s1 = new String("abcd"); String s2 = new String("abcd"); String s3 = s1; if (s1 == s2) {//s1==s3 System.out.println("true"); } else System.out.println("false"); } } 输出的结果是：false
类的引用数据类型
所谓的引用数据类型，实际上传递的就是堆内存的使用权，可以同时为 一个堆内存空间定义多个栈内存的引用操作。如：per1=per2;
垃圾产生的原理：
public class Test { public static void main(String[] args) { Person per1=new Person(); Person per2=new Person(); per1.name="zhangsan"; per1.age=20; per2.name="xzl"; per2.age=34; per2=per1;//在这个过程中，per2放弃了堆内存，指向了per1的堆 内存，所以此时per2的堆内存就是垃圾了 System.out.print("per1中的内容---->"); per1.call(); System.out.print("per2中的内容---->"); per2.call(); } } class Person{ String name; int age; public void call(){
} 输出的结果是：true
封装性
A. 目的：为了是为了保护某些属性和方法，不被外部看见，保护程序 B. 实现封装： -为属性封装：private 属性类型 属性名称； -为方法封装：private 方法返回值 方法名称（参数列表）｛｝ private、public、protected；通常情况下将类的成员变量申明为 private，在通过public的方法对这个变量进行访问。对一个变量的操 作，一般都有读取和赋值操作，我们分别定义两个方法来实现这两种操 作，一个是getXxx(),用来读取这个成员变量的操作，一个是 setXxx()，用来对这个成员变量赋值。
法，编译器会报错，//因为这时编译器不会自动产生不带参数的构造方 法，因为下面已经重载了构造方法 Test t2 = new Test("xzl"); Test t3 = new Test("xzl", 22); t1.test(); t2.test(); t3.test(); } }
匿名对象
在Java中，如果一个对象只使用一次，则就可以将其定义为匿名对象； 如：new Person（）.call()；所谓的匿名对象就是比之前的对象少了一个 栈内存的引用关系； 3. this 关键字的使用，举例如下： public class Test { int age; String name; // 不带参数的构造方法 public Test() { } // 带一个参数的重载构造方法 public Test(String name) { this.name = name;//加上this后，可以增加代码的可读性 } // 带两个参数的构造方法 public Test(String name, int age) { this.name = name; this.age = age; } // 对测试的数据进行输出的函数
对象的进一步研究
Person per=new Person(); A.申明对象：Person per，栈内存中申明的，与数组一样，数组名称就 是保存在栈内存中，只开辟了栈内存的对象是无法使用的，必须有其堆 内存的引用才可以使用； B.实例化对象：new Person（），在堆内存中开辟空间，所有的内容都 是默认值； --String是一个字符串，本身是一个类，就是一个引用数据类型，则 此时默认值就是null; --int 是一个数字，本身是一个数，所以是基本数据类型，则此时的 默认值是0； 如果进一步划分以上代码，可以表示如下： Person per=null;//申明对象 Per=new Person()//实例化对象 开发中，数据最好赋一个初值，了解了其分配的关系，就可以为属性赋 值，并调用类中的方法。使用格式： 调用属性：对象.属性；
实例3：
public class Test { public Test() {//如果不写，编译器会自动创建 System.out.println("hello! boy"); } public static void main(String[] args) { Test t1 = new Test();
访问封装的内容
被封装的属性如果需要被访问，则需要编写setter及getter方法完成，并 且类的属性必须都是封装的，这是必须遵守的 例如：有一个属性 private String name; Setter(设置)：public void setName(String n){} Getter(取得)：public String getName(); 如下面的代码： public class Test { public static void main(String[] args) { Person per1=new Person(); per1.setName("zhangsan"); per1.setAge(-10);//此时存在一个情况，不符合现实中的需求 per1.call(); } } class Person{
封装的类图表示
减号表示用private封装了。
构造函数。
只要一有对象实例化则就会调用构造方法。类名 （）；//调用的就是一个构造方法； 对象=new 类名
构造方法的特征 -它具有与类相同的名称 -构造方法的申明处不能有任何返回值类型的申明 -它不能在方法中用return语句返回一个值； 注意：不同于void,如果加上void，则不会自动调用； 构造方法的作用和调用时机：在申明对象时不会调用，当一个类的实例 对象刚产生时，这个类的构造方法就会被自动调用，主要作用是为类中 的属性进行初始化。 如下面的代码：
一些问题：
a. 对象是保存在栈内存中，属性是保存在堆内存中ຫໍສະໝຸດ Baidu那么方法保存在 哪里的呢?方法是保存在全局代码区之中的，此区中的内容是所有 对象共享的。 b. 在使用对象的时候，对象必须被实例化之后才可以使用（实例化对 象，并不是单单指通过new关键字实现的，只要其有堆内存的空间 指向，则表示实例化成功） c. 如果不实例化会出现：java.lang.NullPointerException（空间指向异 常）的错误，这是在以后程序开发中会经常遇到的问题，应注意。 通常是在引用操作中，如果一个对象没有堆内存的引用，而调用了 类中的属性和方法，就会出现这种问题。 d. 可以产生多个对象，只要按照一定的格式即可。
1. 面向对象是相对于面向过程而言的，面向过程是一种谓语与宾语的 关系，面向对象的是主语与谓语的关系。
面向对象三大特征：
封装：对外部不可见，可以保护程序中的某些内容； 继承：扩展功能 多态：方法的重载，对象的多态性
类与对象的关系（最重要）：
类是对某一类事物的描述，是抽象的、概念上的定义--名词概念；对象 是实际存在的该类事物的每一个个体，因而也称为实例(instance) 2. 类是对某一类事物的描述，是抽象的、概念上的定义；对象是实际 存在的该类事物的每一个个体，因而也称为实例（instance）。 面向对象程序设计的重点是类的设计，而不是对象的设计。 类是通过class创建的，一个类创建后不能直接使用，需要产生对象； 对象产生的格式有两种： A. 类名 对象名称=null;//申明对象 对象名称=new 类名（）；//实例化对象 B.类名 对象名称=new 类名（）；
实例2：
Equals()方法代码如下： public class ForTest { public static void main(String args[]) { String s1 = new String("abcd"); String s2 = new String("abcd"); String s3 = s1; if (s1.equals(s2)) {//s1==s3 System.out.println("true"); } else System.out.println("false"); }
} }
构造方法的重载
和一般的方法重载一样，重载的构造方法具有不同个数或不同类型的参 数，编译器就可以根据这一点判断出用new关键字产生对象时，该调用 哪一个构造方法，产生对象的格式是：new 类名（参数列表）；如下面 的例子：
实例4：
public class Test { int age; String name; // 不带参数的构造方法 public Test() { } // 带一个参数的重载构造方法 public Test(String x) { x = name; } // 带两个参数的构造方法 public Test(String x, int y) { name = x; age = y; } // 对测试的数据进行输出的函数 public void test() { System.out.println(name + "'s age is " + age); } public static void main(String[] args) { Test t1 = new Test();// 如果上面不要不带参数的构造方
类图：
在程序的开发中都是以类图的形式进行说明的，对于一个类来说，形式 如下：
分为三个层次： 第一个层次：表示类名，类的名称要求首字母大写 第二个层次：表述属性的定义，按照"访问权限 属性名称:属性类型"的 格式定义；
第三个层次：表示类中的方法的定义，按照"访问权限 方法名称():方法 返回值"的格式定义。
调用方法：对象.方法(); 如下： public class Test { public static void main(String[] args) { Person per=new Person(); per.name="zhangsan"; per.age=20; per.call(); } } class Person{ String name; int age; public void call(){ System.out.println("the name is:"+name+",age is"+age); } }