Java 面向对象 第一部分(封装)

Java面向对象
一.  面向对象的概述

面向对象是一种思想，是相对面向过程而言的。它把现实生活中存在的每一个事物当成对象。每一个对象都有自己的特征和行为，java将对象的特征描述为属性，将行为描述为功能，并将属性和功能进行封装。强调了具备属性和功能的对象，主体是对象。当我们需要完成某项功能时，就可以直接使用或指挥相关的对象去完成。对于指挥者来说，它只需要知道结果，不关注过程，操作更加简单方便，所以在开发中，我们主要是明确对象，建立对象，找对象使用，维护对象关系。

面向对象的简化理解:

1.     面向对象是面向过程而言的，且基于面向过程。

2.     面向对象是一种思想。

3.     面向对象将功能和数据封装进对象，强调了具备功能的对象，主题是对戏那个，将过程简化。

4.     在实际开发中，以对象为核心，先明确好对象，再实现具体功能，或者可以使用已经有的对象，简单概括就是找对象，建立对象，使用对象。维护对象的关系。

5.     面向对象的三个特征:封装行、继承性、多态性。

二.  类与对象关系

1.     类(class):类就是对现实生活中事物的描述。对象就是这类事物，实实在在存在的个体，类中封装了该类事物的属性和行为。
打个比喻，自然界肯定是先有猫、豹、虎这些动物的存在，科学中才有了对这类动物的一个总体描述，所以科学称这类动物为“猫科类”动物,所以人们一听说“猫科动物”就知道这类动物具备哪些特征，那些基本行为。而在Java中，也是利用事物特征，将客观事物抽象成为类，通过类来产生一个个具体的对象，所以Java中是现有类，然后才有对象，类是创建对象的模版，对象是类的一个具体实例。

2.     类的定义和对象的创建
其实定义类，就是在描述事物，就是在定义属性和行为。属性和行为共同成为类中的成员(成员变量和成员方法)。

类的定义包含两个部分，类的声明和类体，类体中封装了该类事物的属性(成员变量)和成员方法(行为)。
当使用new关键字创建一个对象时候，该对象就在java在堆内存中存在了。类类型变量指向对象。堆内存中的成员变量都有一个默认初始化值。

对象可以使用对象名.成员变量和对象名.成员方法来指挥调用。

 

 
注意:
如果一个java源文件中定义了多个类，那么这些类中最多只能有一个类是public的，换句话说，定义的多个类可以都不是public的。java程序的入口是main方法，所以被定为public的这个类一定是main方法的类，且这个类的名称要和文件名一直，因为虚拟机是要开始找main方法这个入口的。

 

定义类和对象的例子:

/*
*需求: 创建一个汽车类，汽车有品牌名，颜色，有价格，有速度，
*       定义出汽车具备的基本功能，如行驶，发出喇叭声音。
*/
package com.baseObject;
publicclass CarDemo
{
publicstaticvoid main(String[] args)
{
//创建了一个名字为byd和qq的对象。
Car byd =new Car("比亚迪" , 78000.0 , "红色" , 500.0);
Car qq = new Car("奇瑞" , 88000.0 , "黑色" , 550.0);
//对象调用run()方法和sound()方法。
byd.run();
qq.run();
byd.sound();
qq.sound();
}
}
//定义了一个汽车类，汽车具备品牌名、颜色、价格等属性，还具备行驶，响喇//叭的功能
class Car
{
private Stringname;
privatedoubleprice;
private Stringcolor;
privatedoublespeed;
public Car(String name ,double price , String color ,double speed)
{
this.name = name;
this.price = price;
this.color =color;
this.speed = speed;
}
publicvoid run()
{
System.out.println(this.name + "正在高速上嗖嗖的行驶....");
}
publicvoid sound()
{
System.out.println("叭叭...叭叭...");
}

}

3.     new关键字创建对象的过程

Car byd = new Car("比亚迪"
, 78000.0 , "红色"
, 500.0);

该句话都做了什么事情？

A.     因为new用到了Car.class.所以会先找到Car.class文件并加载到内存中。

B.     执行该类中的static代码块，如果有的话，给Car.class类进行初始化。

C.     在堆内存中开辟空间，分配内存地址。

D.    在堆内存中建立对象的特有属性。并进行默认初始化。

E.     对属性进行显示初始化。

F.      对对象进行构造代码块初始化。

G.    对对象进行对应的构造函数初始化。

H.    将内存地址付给栈内存中的byd变量。
三.  成员变量和局部变量

1.     成员变量:成员变量必须定义在类中，是该类事物的特征属性、数据。

A.    作用范围:作用于整个类中。

B.     内存中的位置:在堆内存中，因为对象的存在，才在内存中存在。

C.     初始化方式:随着对象的初始化而初始化，如果没有指定初始化值，那么在初始化时就赋上默认值，所以成员变量可以不赋值就直接参与运算。

2.     局部变量:定义在成员方法或者语句块中的变量。

A. 作用范围:作用于成员方法中，或者语句块。

B.内存中的位置:存在于栈内存中，随着函数的结束而消亡
C.随着方法的加载而加载进栈内存中，无初始化值，必须先赋值才能参与运算
四.  匿名对象

1.     含义:所谓匿名对象，就是创建的对象没有名字，即没有类的引用指向这个对象，使用new出来直接使用的对象，例如:

new Car("比亚迪" , 78000.0 , "红色" , 500.0).run();

2.     使用方式

A.     当对对象的方法只调用一次时，可以用匿名对象来完成，这样写比较简化，如果对一个对象进行多个成员调用，必须给这个对象起个名字。

B.     可以将匿名对象作为实际参数进行传递。

3.     生命周期:匿名对象在被使用一次，或者说被用来调用一个成员方法，当方法结束后，垃圾回收机制会将这个匿名对象作为垃圾回收，非匿名对象则不同了，它是在这个对象不在被使用，或随着主函数的结束而被回收。

封装性
一.  封装的概述

A.     定义:封装是指隐藏对象的属性和实现细节，仅仅对外提供了可见的公共的方法方式，或方法。

A.     将不需要或则不能对外提供的内容隐藏起来，进行封装。

B.     把属性都隐藏起来，对外提供一个接口(公共方法)对其访问和设置。
说明:

A.    私有仅仅是封装性的表现形式之一，如包也是一种封装形式。

B.     之所以对外提供访问方式，就是因为可以在访问方式中加入逻辑判断等语句，对访问的数据进行操作，提高了代码的健壮性。

二.  封装性的优点

1.     提高了代码的健壮性

2.     将变化隔离

3.     便于使用

4.     提高重用性

5.     提高安全性
 

三.  private关键字

1.     private关键字是一个权限修饰符。

2.     只能用于修饰成员变量和成员方法。

3.     被私有化的成员变量和成员方法，对外部是不可见的，只在本类中有效。

4.     我们可以将成员变量修饰成private，使其隐藏，但是可以在类中提供对应的setXXX(),getXXX()方法对这些成员变量进行访问和设置，提高了数据访问的安全性。

5.     当把类中的所有构造函数私有化后，代表着该类是不能创建对象的，因为在外部无法调用private修饰构造函数进行对象和成员变量的初始化，当然即使在类内部定义一个main()方法，在其里面依然不能创建对象，因为main()方法必须是静态的，静态的方法不能访问非静态的方法，而且构造方法不能被修饰为静态的。

package com.baseObject;
publicclass PrivateDemo
{
publicstaticvoid main(String[] args)
{
Person p =new Person();
p.setAge(0);
p.setName("Ansen");
System.out.println("姓名:"+ p.getName() + " 年龄："+ p.getAge());
}
}
class Person
{
//将age和name进行私有化
privateintage;
private Stringname;
//对外提供一个可供用来设置年龄的方法，并对传入的年龄进行check，是否符合//规则
publicvoid setAge(int age)
{
if(age >= 130 || age < 0 )
{
System.out.println("年龄不合法。");
}
else
{
this.age = age;
}
}
//对外提供姓名设置的方法
publicvoid setName(String name)
{
this.name = name;
}
//对外分别提供获取年龄和获取姓名的方法。
public String getName()
{
returnname;
}
publicint getAge()
{
returnage;
}
}

方法与代码块

一.   main方法

我们从接触java到现在，时时刻刻都在用main()方法，那么main()方法是干什么用的呢？有什么含义呢？

public static void main(String [] args){....}

1.     main()方法，也称为主函数，是一个特殊的函数，这个函数都会定义在被public修饰的类中，public
static void main(String args[])写法是固定的。

2.     main方法修饰符即参数的含义

A.     public:代表该函数的访问权限是最大的。

B.     static:代表着主函数随着类的加载而加载，类存在这个主函数就存在了，以便执行主函数中的代码，因为一个独立的java应用程序的入口是main函数，必须在类加载的时候而存在。

C.     void:表示主函数没有具体的返回值，只是程序执行的入口，换句话说，启动或调用这个主函数的是虚拟机，总不能说返回一个值给虚拟机吧。

D.    main:不是关键字，但是是一个特殊的单词，可以给虚拟机识别作为程序入口的函数名。

E.     (String [] args))：函数的参数，参数类型是一个String类数组，元素为字符串。字符串类类型是数组，args是一个变量名，早期被写成arguments；如果改写成其他名称也是可以的，这个参数可以用来接收运行程序时用户设定的参数。

注意:可以重载主函数，但是虚拟机只识别固定格式的主函数，即 public
static void main(String [] args){....}。

二.  构造方法

1.     定义:构造方式一种特殊的方法，它的名字必须与它锁在类的名字完全相同，并且没有返回值类值，也不需要void关键字标识，但是可以有一个或者多个参数，也可以没有，也不能在构造函数中使用return关键字，构造方法用于对对象中的所有成员成员变量进行初始化，在创建对象时立即被调用，需要注意的，如果用户没有定义构造方法，java会自动提供一个默认的构造方法，用来实现成员变量的初始化。

2.     特点:

A.     函数名与类名相同

B.     不能定义返回类型，括号中的参数可以没有，也可以有多个。

C.     不可以写return语句

D.    构造函数总是伴随着new操作一起被调用。

E.     当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数，即：类名(){}。但当类中自定义了构造函数后，默认的构造函数就不存在了。也就是说，每一个类中一定含有一个构造函数。

F.      一个类中可以有一个或者多个构造方法存在，而多个构造方法存在是一重载的方式存在的。

3.     作用:给对象成员变量进行初始化

4.     构造方法和一般成员方法的区别

A.    构造函数时在对象一建立就运行，是给对象初始化的。且一个对象建立后，构造函数只运行一次。一般函数是对象调用才执行，是给对象添加对象具备的功能的。一般函数可以被该对象多次调用。

B.     一般函数是不能调用构造函数的，因为一般函数中不能定义this，而构造函数中可能存在this。

5.     何时使用构造方法

当分析事物时，该事物存在具备一些特性或行为，那么将这些内容定义在构造函数中。也就是说，一类事物一出现就应该存在的特性，这就需要构造函数对其进行初始化。

 

三.  构造代码块

1.     什么是构造代码块？
构造代码快是定义在类中，不能定义在方法中，是用一对花括号括起来的代码块，成为构造代码块，给对象进行初始化，对象一建立就运行，且优先于构造函数执行，即在构造函数前加载。

publicclass Person
{
privateintage ;
private Stringname ;
{
System.out.println("呜呜.....呜呜");//构造代码块，每个人生下来都会哭。
}
public Person(int age)
{
this.age =age;
}
public Person(int age , String name)
{
this(age);
this.name =name;
}
}

2.     与构造函数的区别

构造代码块是给所有对象进行统一初始化，是所有对象的共性初始化方式内容，如任何婴儿出生都要哭几声，构造函数是给对应的对象初始化，不同的对象有各自的特性，需要选择不同的构造函数初始化。

 

四.  this关键字

1.     定义:this表示当前对象(当前正在调用类中成员或构造方法的对象)。

2.     this关键字的特点

A.    this代表了本类的对象，即代表了它所在函数所属对象的引用，也就是说，哪个对象调用这个函数，this就代表哪个对象，也可以说当前正在调用类中成员或构造方法的对象。

B.     一般情况下，this都是被省略的，需要使用的时候才需加上。

3.     this的用法

A.    用于区分同名的局部变量和成员变量，也就是说当类中的某个方法中定义了一个局部变量，而这个局部变量和类中的某个成员变量同类型并且同名，那么这时我们要在局部访问或操作这个成员变量的时候，则肯定是操作局部的这个变量，可是我们实际的是想访问或操作成员变量，那么这时候我们可以用this.成员变量名的方法去区分访问。

 

class Person
{
privateintage = 24;
private Stringname ="Ansen";
//构造函数接收两个参数，这两个参数就是两个局部变量，
//当我们要将这两个局部变量的值赋给成员变量的时候，就要用
//this关键来对它们进行操作了。
public Person(int age , String name)
{
this.age = age;
this.name = name ;
}
}
B.     用于构造函数之间的调用

publicclass Person
{
privateintage ;
private Stringname ;
private Stringid;
public Person(int age)
{
this.age =age;
}
public Person(intage , String name)
{
this(age);//调用只有一个参数的构造方法为age赋值。
this.name =name;
}
public Person(int age , String name,String id)
{
this(age , name);//调用两个参数的构造方法为age和name赋值。
this.id = id;
}
}

注意:

1.     用于构造方法之间的调用，必须有一个构造方法是没有使用this关键字去调用其他构造方法的，否则就存在一个死循环调用的结果。

2.     而且还必须放在构造调用构造方法的第一行语句，否则编译失败

五.  static关键字

1.     定义:static关键字是一个修饰符，可以用来修饰成员变量，成员方法(不可以用来修饰构造函数)，当成员变量或成员方法被static关键字修饰之后，表示它们是静态公有的，是属于类的，并不属于某个对象的。

2.     static的特点

A.     用来修饰成员变量和成员方法,当修饰为static之后，就多了一种调用方法，除了使用对象.成员之外，多了一种直接使用类名.成员的调用方式。

B.     当修饰成员变量和成员方法的时候，这些成员变量和成员方法会随着类的加载而别加载，在类或内存中的声明周期是最长的。

C.     因为static修饰的成员变量和成员方法是是随着类的加载而加载，所以会先于对象的存在，因为对象只有在类被加载之后，才能去创建对象，而此时类一加载还没有对象存在，所以是先于对象存在的。

D.    静态的成员变量和成员方法是被所有对象共享的，并不是属于某个对象，而是属于类的。

E.     可以通过类名称直接调用。

F.      静态方法只能调用静态的方法或静态的变量，因为非静态的是属于对象的，static修饰的成员变量和成员方法是是随着类的加载而加载，所以会先于对象的存在，因为对象只有在类被加载之后，才能去创建对象，而此时类一加载还没有对象存在，而非静态的方法是属于对象，如果此时没有对象，调用就会失败。

G.    static关键字不能用来修饰局部变量，因为局部变量所用范围是方法内部或者代码块中，而static是作用于整个类，是被所有对象共同访问的使用的，它是类加载时候就存在的，直到这个类不在被使用或则jvm退出时候才可能被垃圾回收机制回收，而局部变量是方法执行完毕，就会被回收，但是此时对象或类并没有使用完毕，静态的变量还存在。

H.    static修饰的成员是存放在内存的共享区(方法区，数据区)中

3.     静态常量
使用static和final修饰的变量就是常量，常量的值是不可以被修改的，静态常量不但不可以改变，而且是共享的。我们知道计算圆的周长面积体积等计算用的π的值是被明确固定下来的，那么我们如果在开发中，程式中要用到这个值，就可以将它定义为静态常量。

public class Math
{
...
public static final double PI = 3.14159265358979323846;//final将PI设置为不可再定义的常量
...
}

如果省略了static，PI就变成了一个实例常量，那么，每一个Math对象就都有自己的一个PI拷贝了，这样的话，对内存也是一种占用。
 

 

4.     静态变量

 

class Student
{
private String id;
private static String country ="china";
//获取id的访问器
public String getId()
{
return id;
}
public void setId(String id)
{
this.id = id;
}
}

以上就定义了一个静态变量，我们知道每一个学都有学号id，都已一个国籍，对于中国的学生来讲，没一个学生国籍都是中国，那么可以将过激country定义为静态变量，以便所有对象使用，这样每一个对象就不用去copy一份country到自己的堆内存中，减少了对内存的开销。

6.     静态方法
当方法被static修饰的时候，此方法是用类名.方法名的方式使用的，当然也可以用对象名.方法名，但是这样就会产生误解，会让别人以为这个方法是非静态的，这样就有些不合理了。但是静态方法有一点需要注意的是：静态方法只能访问静态成员，因此静态方法也就不能定义this和super等关键。

7.     静态的应用
当每个应用程序都有共同之处，可将其封装，提高其复用性。
需要注意的是:

A. 对象时用于封装数据的。

B.对数据的操作方法，若没用到方法中特有的数据，则无需创建对象而占用多余的内存。

8.     静态代码块
静态代码块是定义在类中的，不能定义在方法中，是使用static后面跟一对花括号的代码块，如下所示:

publicclass Person
{
privateintage ;
private Stringname ;
static
{
System.out.println("类加载完毕");//定义了一个静态代码块
}
public Person(int age)
{
this.age =age;
}
public Person(int age , String name)
{
this(age);
this.name =name;
}
}

静态代码块的特点:

A.      随着类的加载而被执行，而且优先与主函数执行

B.     只有在类被加载的时候执行一次，之后不在执行。

 

9.     静态的有点和缺点
好处 :对对象的共享数据惊醒单独空间的存储，节省空进。没必要每个对象中都要存储一份，可以直接被类名调用
弊端 :生命周期过长。访问出现局限性，因为静态只能访问静态。

class Student
{
private static String country = "CN";//因为国家是共有的，共享
private int id;
private static int nextId = 1;
//静态代码块
static
{
System.out.println("Hello");
}
public static String getCountry()
{
return country;
}
public int getId()
{
return id;
}
public void setId()
{
id = nextId;
nextId++;//前一个人获取id后，然后一个人获取下一个id时就加1
}
}

class StudentText
{
public static void main(String [] args)
{
Student st1 = new Student();
st1.setId();
System.out.println("st1'country = " + Student.getCountry() + "; st1id = " + st1.getId());
Student st2 = new Student();
st2.setId();
System.out.println("st2'country = " + Student.getCountry() + "; st2id = " + st2.getId());
}
}

六.  final关键字

1.     定义:译为最终。是java中的修饰符

2.     final关键字的特点:

A. 可以用来修饰变量(成员变量，局部变量，静态变量)，可以用来修饰成员方法，但是不可以用来修饰构造方法，可以用来修饰类

B. 被用来修饰变量，表示这个变量的值将不能改变，是一个常量，只能赋值一次。
应用:当在描述事物时，一些数据的出现值是固定的，那么这时为了增强阅读性，都给这些值起个名字，方便于阅读，而这个值不需要改变，所以加上final修饰。作为常量：常量的书写规范所有字母都大写，如果由多个单词组成，单词间通过_连接。
如：数学函数中的圆周率PI是一个固定值，在java中北定义为final的，是为了让程序更加
 public static final double PI = 3.141592654

C. 被用来修饰方法的时候，表示该方法不能被复写。

D. 被用来修饰类的时候，表示该类不能被继承，要防止被子类将本来功能复写。

E. 内部类定义在类中的局部位置上是，只能访问该局部被final修饰的局部变量。

F.抽象类和接口不能用final来修饰，即一个类不能既是最终类又是抽象类。