面向对象----类和对象

Posted 2020-09-29 未来_我来

类和对象

理解面向对象的概念

面向过程

在一个结构体中定义窗口的大小，位置，颜色，背景等属性，对窗口操作的函数与窗口本身的定义没有任何关系，如HideWindow，MoveWindow，MinimizeWindow，这些函数都需要接受一个代表要被操作的窗口参数 ，是一种谓语与宾语的关系 。

 

面向对象

定义窗口时，除了要指定在面向过程中规定的那些属性，如大小，位置，颜色，背景等外，还要指定该窗口可能具有的动作 ，如隐藏，移动，最小化等。这些函数被调用时，都是以某个窗口要隐藏，某个窗口要移动的语法格式来使用的 ，这是一种主语与谓语的关系。

面向对象的三大特征

封装 (Encapsulation)
继承 (Inheritance)
多态 (Polymorphism)

面向对象的思想概述

面向对象的编程思想力图使计算机语言中对事物的描述与现实世界中该事物的本来面目尽可能的一致。
类(class)和对象(object)是面向对象方法的核心概念。类是对一类事物描述，是抽象的、概念上的定义；对象是实际存在的该类事物的每个个体，因而也称实例(instance)。

如果将对象比作汽车，那么类就是汽车的设计图纸。所以面向对象程序设计的重点是类的设计，而不是对象的设计。

类和对象举例
　　//定义一个类
　　public class Animal {
　　　　public int legs;
　　　　public void eat() {
　　　　　　System.out.println(“Eating.”);
　　　　}
　　　　public void move() {
　　　　　　System.out.println(“Moving.”);
　　　　}
　　}
　　//声明并创建一个Animal类的对象，将该对象命名为xb
　　Animal xb = new Animal();
　　//调用对象xb中的方法
　　xb.eat();

 

类的定义

public class Animal {
　　public int legs;
　　public void eat() {
　　　　System.out.println(“Eating.”);
　　}
　　public void move() {
　　　　System.out.println(“Moving.”);
　　}

}
　　legs是类的属性 ，也叫类 成员变量 。
　　eat,move是方法也叫类的 成员函数。

1、使用 class 关键字定义了一个类: Person

 1 /**
 2  * 使用 class 关键字定义了一个类: Person
 3  */
 4 public class Person {
 5 
 6     //定义类的属性: 类型 属性名
 7     String name = "unknown";
 8     
 9     //类型 变量名 = 初始值
10     int age = -1;
11     
12     //Java类中，一旦类的定义者显式定义了一个或多个构造方法，系统将不再提供默认的构造方法；
13     public Person(String personName, int personAge){
14         System.out.println("洗澡...");
15         
16         name = personName;
17         age = personAge;
18     }
19     
20     //定义类的方法
21     //带返回值的: 返回值类型 方法名(){ 有可能使用 return 返回具体的值 }
22     int getAge(){
23         return age;
24     }
25     
26     //没有返回值的方法: 也开始使用 return 标示方法结束
27     //return 标示方法结束, return 的后面不能再有其他语句. 
28     void shout(){
29         System.out.println("I am " + name);
30         return;
31     }
32     
33     //带参数, 但没有返回值的方法
34     void hello(String personName){ 
35         System.out.println("Hello: " + personName);
36     }
37     
38     //带参数, 且有返回值的方法
39     int add(int i, int j){
40         int result = i + j;
41         return result;
42     }    
43 }

2、测试类

 1 /**
 2  * 测试类 4  */
 5 public class TestPerson {
 6     public static void main(String[] args) {
 7         
 8         //3. 匿名对象: 没有名字的对象. 
 9         new Person("A", 10).shout();
10         
11         //2. 创建一个 Person 对象 p2
12         Person p2 = new Person("B", 20);
13         p2.shout();
14         p2.hello("Mike");
15         
16         int result2 = p2.add(1, 4);
17         System.out.println(result2);
18         int age2 = p2.getAge();
19         System.out.println(age2); //10. 定义类时的初始值
20         
21         //p1 和  p2 是 Person 的两个对象, 操作任何一个的(非静态的)成员变量, 并不会对另一个对象的属性产生影响. 
22         p2.age = 100;
23         
24         System.out.println(); 
25         
26         //1. 创建一个 Person 对象 p1
27         //使用 new 关键字创建一个对象. 
28         Person p1 = new Person("C", 30);
29     
30         //为对象的属性赋值, 使用 . 操作符
31         p1.age = 30;
32         p1.name = "Tom";
33         
34         //调动对象的方法, 使用 . 操作符
35         int result = p1.add(2, 5);
36         System.out.println(result);
37         
38         int age = p1.getAge();
39         System.out.println(age); //30. 在 31 行为 p1 的 age 赋的值
40         p1.hello("Jerry");
41         p1.shout();
42     }
43 }

 

声明类、属性、方法

声明类

语法格式：
　　[< 修饰符>] class < 类名>
　　{
　　　　[<属性声明>]
　　　　[<构造器声明>]
　　　　[<方法声明>]
　　}

说明：修饰符public：类可以被任意访问
　　　类的正文要用{ }括起来
举例：
　　public class Person{
　　　　private int age ; //声明私有变量 age
　　　　public void showAge(int i) { //声明方法showAge
　　　　　　age = i;
　　　　}
　　}

 

声明属性

语法格式：
　　[<修饰符>] 类型 < 属性名> [=初值] ;

说明：修饰符 private: 该属性只能由该类的方法访问。
修饰符 public: 该属性可以被该类以外的方法访问。
类型：任何基本类型，如int、boolean或任何类。

举例：
public class Person{
　　private int age; //声明private变量 age
　　public String name = “Lila”; //声明public变量 name
}

属性有时也称为：数据成员(数据)，成员变量(变量)

声明方法

语法格式：
　　<修饰符> <返回类型> <方法名>([< 参数表>]) {
　　　　[< 语句>]
　　}
说明： 修饰符：public,private,protected 等。
返回类型：return语句传递返回值。没有返回值：void。

举例：
public class Person{
　　private int age;
　　public int getAge() { return age; } //声明方法getAge
　　public void setAge(int i) { //声明方法setAge
　　　　age = i; //将参数i的值赋给类的成员变量age
　　}
}
方法有时也称为：成员函数(函数)

 

创建、使用对象

使用 new +构造方法 创建一个新的对象；
使用 “对象名.对象成员” 的方式访问对象成员（包括属性和方法）；
public class Animal {
　　public int legs;
　　public void eat() {
　　　　System.out.println(“Eating.”);
　　}
　　public viod move() {
　　　　System.out.println(“Move.”);
　　}
}

举例:
public class Zoo {
　　public static void main(String args[]) {
　　　　Animal xb=new Animal();
　　　　xb.legs=4;
　　　　System.out.println(xb.legs);
　　　　xb.eat();
　　　　xb.move();
　　}
}
如果创建了一个类的多个对象，对于类中定义的属性，每个对象都拥有各自的一套副本，且互不干扰。

举例:
public class Zoo {
　　public static void main(String args[]) {
　　　　Animal xb=new Animal();
　　　　Animal xh=new Animal();
　　　　xb.legs=4;
　　　　xh.legs=0;
　　　　System.out.println(xb.legs); //4
　　　　System.out.println(xh.legs); //0
　　　　xb.legs=2;
　　　　System.out.println(xb.legs); //2
　　　　System.out.println(xh.legs); //0
　　}
}

类的访问机制：
在一个类中的访问机制：类中的方法可以直接访问类中的成员变量。（有一个例外）
在不同类中的访问机制：先创建要访问类的对象，再用对象访问类中定义的成员。
创建新的对象之后,我们就可以使用“ 对象名.对象成员 ”的格式，来访问对象的员

class TestPerson {
　　public static void main(String[] args) {

　　　　Person p1 = new Person();
　　　　Person p2 =new Person();
　　　　p1.age = -30;
　　　　p1.shout();
　　　　p2.shout();
　　}
}

对象的生命周期

 

匿名对象

我们也可以不定义对象的句柄，而直接调用这个对象的方法。这样的对象叫做匿名对象， 如：new Person().shout();
如果对一个对象只需要进行一次方法调用，那么就可以使用匿名对象。
我们经常将匿名对象作为实参传递给一个函数调用。

练习
1、要求：

　　(1)创建Person类的对象，设置该对象的name、age和sex属性，

　　　调用study方法，输出字符串“studying”，

　　　调用showAge()方法显示age值，

　　　调用addAge()方法给对象的age属性值增加2岁。

　　(2)创建第二个对象，执行上述操作，体会同一个类的不同对象之间的关系。

 

 1 public class Person {
 2 
 3     public String name;
 4     public int age;
 5     public int sex;
 6     
 7     public void study(){
 8         System.out.println("studying");
 9     }
10     
11     public void showAge(){ 
12         System.out.println(age);
13     }
14     
15     public void addAge(){
16         age += 2;
17     }
18 }

 

 1 public class TestPerson {
 2     public static void main(String[] args) {
 3         
 4         Person1 p1 = new Person1();
 5         
 6         p1.age = 10;
 7         
 8         p1.study();
 9         p1.showAge(); //10
10         
11         p1.addAge();
12         p1.showAge(); //12
14     }
15 }

 

 

2、利用面向对象的编程方法，设计类Circle计算圆的面积。

 

 1 public class Circle {
 2     public static void main(String arg[]) {
 3              
 4     //半径
 5     int redius;
 6 
 7     //返回圆的面积
 8     public double findArea() {
 9         return 3.14 * redius * redius;
10     }
11  }

 

 

 

1 public class TestCircle {
2       public static void main(String arg[]) {
3             Circle c = new Circle();
4             c.redius = 2;
5             System.out.println(c.findArea());
6     }  
7 }