Java基础语法（四）-----面向对象（1）基础概念、封装

一、 面向对象思想

1、概述

面向过程我们来回想一下，这几天我们完成一个需求的步骤：首先是搞清楚我们要做什么，然后在分析怎么做，最后我们再代码体现。一步一步去实现，而具体的每一步都需要我们去实现和操作。这些步骤相互调用和协作，完成我们的需求。在上面的每一个具体步骤中我们都是参与者，并且需要面对具体的每一个步骤和过程，这就是面向过程最直接的体现。

那么什么是面向过程开发呢?面向过程开发，其实就是面向着具体的每一个步骤和过程，把每一个步骤和过程完成，然后由这些功能方法相互调用，完成需求。

面向过程的代表性语言就是C语言。

2、面向对象

当需求单一，或者简单时，我们一步一步去操作没问题，并且效率也挺高。可随着需求的更改，功能的增多，发现需要面对每一个步骤很麻烦了，这时就开始思索，能不能把这些步骤和功能在进行封装，封装时根据不同的功能，进行不同的封装，功能类似的封装在一起。这样结构就清晰了很多。用的时候，找到对应的类就可以了。这就是面向对象的思想。接下来我们看看面向对象到底是什么?

* 面向对象思想：面向对象是基于过程的编程思想

* 面向对象开发：就是不断地创建对象、调用对象、指挥对象解决问题

* 面向对象设计：其实就是管理和维护对象之间的关系

* 面向对象的特征：封装、继承、多态

二、 类与对象及其使用

1、 类与对象的关系
* 类：是一组相关的属性和行为的集合

* 对象：是该类事物的具体体现

例如：创建一个学生类（可以是姓名、年龄、班级等属性的集合），而定义一个学生类的对象，可以是班长，班长是学生的具体体现。

类与对象的关系也可如图所示：有一个水果类，梨、苹果、桃子都是该类的一个具体对象。



2、 类的定义


定义类其实就是定义类的成员，即成员变量和成员方法。

具体案例：定义一个学生类Student

* 定义一个Student类（分析该类应具有的属性、功能）

* 创建对象：类名 对象名 = new 类名（）；

* 使用对象：对象名.成员变量；

对象名.成员方法名（参数...）；

public class Student {
//成员属性
String name;//姓名
int age;//年龄
//成员方法
void doHomework(){
System.out.println("学生每天都要做作业");
}
}

测试类：

public class Text {

public static void main(String[] args) {
//创建对象
Student stu = new Student();
//使用对象
int age = stu.age ;
String name = stu.name ;
stu.doHomework();
}

}

3、 对象的内存图解
以上面的学生类为例，



4、 成员变量和局部变量的区别
* 在类中的位置不同

成员变量定义在方法外，局部变量定义在方法内

* 在内存中的存储位置不同

成员变量存储在堆内存中，局部变量存储在栈内存中

* 生命周期不同

成员变量随着对象的加载而加载，随着对象的消失而消失；局部变量随着方法的调用而存在，随着方法的调用完毕而消失

* 初始值不同

成员变量有默认的初始值，局部变量没有默认初始化值，必须先经过定义，赋值，才能使用。

注意：当成员变量和局部变量重名时，我们采取就近原则。

例：Teacher类

public class Teacher {
public String tname;
public int tage;

public void show(String tname){
//当成员变量和局部变量重名的时候，我们采用的就是就近原则
System.out.println("第一句打印的是"+tname);
System.out.println("第二句打印的是"+tname);
System.out.println("第三句打印的是"+this.tname);
}
}

//测试类

public class Test {

public static void main(String[] args) {

Teacher teacher = new Teacher();
teacher.tname="小明";
teacher.show("小红");
}

运行结果：




5、 形式参数问题（基本数据类型、引用数据类型）
* 基本数据类型作为形式参数：基本数据类型的数据的改变不会影响实参的值

* 引用数据类型作为形式参数：其值的改变会直接影响实参的改变

例：

public class Student {
public String name;
public String sex;
public int age;

}

public class Text {

public static void main(String[] args) {
Student stu = new Student();
stu.age =18;
stu.name ="lisi";
System.out.println(stu.age);
System.out.println(stu.name);
//传参
show(stu);//引用数据类型作为形式参数传递
show(stu.name);//基本数据类型作为形式参数传递
System.out.println(stu.age);
System.out.println(stu.name);

}
public static void show(Student stu){
stu.age =20;
}
public static void show(String name){
name="zhangsan";
}

}

三、匿名对象

* 匿名对象：就是没有名字的对象，是对象的一种简化表现形式

*匿名对象的两种使用情况：

该对象调用方法仅使用一次的时候；

作为实际参数传递；

注意：匿名对象每new一次，都是不同的对象

案例：创建一个Student学生类，测试类如下例题

public class Student {
public String name;
public String sex;
public int age;

public Student getStudent(Student stu,String name,int age){
stu.name =name;
stu .age =age ;
return stu;
}
public void show(){
System.out.println("这是一个学生类");
}
}

例1：创建匿名对象

public class Text {

public static void main(String[] args) {
new Student();//创建匿名对象1
new Student();//匿名对象2
//两次打印对象的地址值不同
System.out.println(new Student());
System.out.println(new Student());

}
}

运行结果：

YinLi.Student@6d06d69c

YinLi.Student@7852e922

例2：匿名对象传参

public class Text {

public static void main(String[] args) {
Student stu1=new Student();
stu1.name ="Jack";
stu1.age=18;
stu1=stu1.getStudent(stu1, "Lily", 24);//非匿名对象传参
System.out.println(stu1.name );
System.out.println(stu1.age );
//匿名对象传参
Student stu2=stu1.getStudent(new Student(), "Bob", 19);
System.out.println(stu2.name );
System.out.println(stu2.age );
}
}

运行结果：

Lily

24

Bob

19

例3：有时只想调用一次成员方法，我们可以使用匿名对象

public class Text {

public static void main(String[] args) {
new Student().show();
}
}

四、封装

*封装概述：是指隐藏对象的属性和实现细节，仅对外界提供公共的访问方式。

*好处：

隐藏实现细节，提供公共的访问方式

提高了代码的复用性

提高安全性。

* 封装原则：

将不需要对外提供的内容都隐藏起来。

把属性隐藏，提供公共方法对其访问。

五、private关键字

之前，我们都是用public权限修饰符来修饰变量的，通过 对象名.成员变量 这种方式给变量赋值，但是这种赋值方式是不好的，因为这种赋值方式会赋上不合理的数据，如：给人的年龄赋值200，这明显是不合理的，因此，出于数据安全和合理性方面的考虑，我们应该屏蔽掉这种设置成员变量值得方式。就需要权限修饰符private来限定变量的使用，在类中提供一个公共的get和set方法来设置和获取值。

private关键字，是一种权限修饰符，可以修饰成员变量和成员方法，被private修饰的成员只能在本类中被访问。

建立一个标准的案例，使用private：

建立一个Person类，创建对象、赋值，并测试

public class Person {
//来写一个标准的类型
//1.私有化成员变量
private String name;
private int age;
//提供公共的set get 方法用来设置值，和获取值
public void setName(String mingzi){

name=mingzi;

}
public void setAge(int nianling){

age=nianling;

}
public String getName(){

return name;
}
public int getAge(){

return age;
}

}

测试类：

public class Test {

public static void main(String[] args) {
Person person=new Person();
person.setName("Bob");
person.setAge(18);

String name = person.getName();
int age = person.getAge();

System.out.println(name);
System.out.println(age);

}

}

** private和public的区别：

1、private可以修饰成员变量、成员方法、内部类，但是只能在本类中被访问，其他类不能直接通过对象名来访问。

2、public也是权限修饰符，可以修饰类、成员变量、成员方法，被public修饰的可以在其他类中直接通过对象名来访问。

例：

public class Student {
private String name;
private String sex;
private int age;

//get 和 set方法来设置和获取成员变量
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}

public void show(){
System.out.println("这是一个公有的学生类方法");
}
private void showing() {
System.out.println("这是一个私有的学生类方法");
}
}

测试类：

public class Text {

public static void main(String[] args) {
Student stu1=new Student();
stu1.name ="Jack";
stu1.age=18;

//		System.out.println(stu1.name );
//		System.out.println(stu1.age );
}
}

说明：通过对象stu1直接在Text类中打点访问Student类中被private修饰的变量name和age编译会报错，如下：



同样，也不能直接调用showing()方法。

正确的做法如下：

public class Text {

public static void main(String[] args) {
Student stu1=new Student();
stu1.setName("Bob");
stu1.setAge(18);
String name = stu1.getName();
int age = stu1.getAge();

System.out.println(name );
System.out.println(age );
}
}

被private修饰的showing方法只能在Student类中被访问。

六、this关键字

this:是指该类对象的一个引用，可以记为 "谁调用我，我就指代谁"。

** 当局部变量和成员变量重名时，可以通过使用this关键字来区分。如下：

public class Animal {
private String name;
private int age;

public void setName(String name){  //局部变量：name
this.name=name;  //this.name中的name是成员变量

}

}

** 谁调用this，this就指代谁

public class Animal {
private String name;
private int age;

public void setName(String name){
this.name=name;
}

public void setAge(int age){
//当局部变量和成员变量重名的时候，我们可以用this 去区分这两个变量
this.age=age;
}
public String getName() {
return this.name;
}

public int getAge() {
return this.age;
}
public Animal getAnimal(Animal an) {
//当你看到一个方法的返回值 要一个 类 类型 你得返回一个该类的对象
an.setName("熊大");
return this;
}

}

测试类：

public class Test {

public static void main(String[] args) {
Animal a = new Animal();
a.setName("猴子");

//this 关键字，代表一个本类的对象（引用）， 谁调用我 我就代表谁
Animal animal = new Animal();
Animal animal2 = a.getAnimal(animal);
System.out.println(animal2.getName());
System.out.println(animal.getName());

}

}

运行结果：



说明：Animal animal2 = a.getAnimal(animal);表示对象 a 调用getAnimal()方法，所以 getAnimal()方法中的this返回值指的就是返回对象 a。又将返回的对象 a 赋给对象animal2，因此animal2和对象 a 指的是同一个引用，所以第一次打印结果为“猴子”。 因为传递的参数是引用类型数据（对象animal），且在getAnimal()方法中将其名字改为“熊大”，因此，第二次打印结果为“熊大”。

七、static关键字

static是静态的意思，既可以修饰变量，也可以修饰方法，还可以修饰类。

** static关键字的特点：

所属于类，随着类的加载而加载；

优先于类存在；

被类中的所有对象共享；

可以通过类名直接调用被Static修饰的变量和方法。

** 静态的内存图：静态的内容存在于方法区的静态共享区。



** static关键字注意事项：

1、在静态方法中是没有this关键字的。

因为this指代的是一个对象，而静态方法是先于对象存在的，因此静态方法此时是访问不到还没有创建的对象的.

2、静态的方法只能访问静态的成员变量或方法。原因同上。

** 静态变量与成员变量的区别

1、所属不同

• 静态变量属于类，所以也称为为类变量

• 成员变量属于对象，所以也称为实例变量(对象变量)

2、内存中位置不同

• 静态变量存储于方法区的静态区

• 成员变量存储于堆内存

3、内存出现时间不同

• 静态变量随着类的加载而加载，随着类的消失而消失

• 成员变量随着对象的创建而存在，随着对象的消失而消失

4、调用不同

• 静态变量可以通过类名调用，也可以通过对象调用

• 成员变量只能通过对象名调用

九、代码块

在Java中，使用{}括起来的代码被称为代码块，根据其位置和声明的不同，可以分为局部代码块，构造代码块，

静态代码块，同步代码块(多线程讲解)。

•局部代码块

在方法中出现；限定变量生命周期，及早释放，提高内存利用率。

•构造代码块

在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行。

•静态代码块

在类中方法外出现，加了static修饰；

用于给类进行初始化，在加载的时候就执行，并且值执行一次。

注意事项：

静态代码块先执行：随着类的加载而加载,只执行一次

构造代码块，优先于构造方法先执行 构造代码块和构造方法是每new一次就会执行一次

例：

//学生类
class Student {
static {
System.out.println("Student 静态代码块");//3
}

{
System.out.println("Student 构造代码块");//4 6
}

public Student() {
System.out.println("Student 构造方法");//5 7
}
}

//测试类class StudentDemo {
static {
System.out.println("StudentDemo的静态代码块");//1
}

public static void main(String[] args) {
System.out.println("我是main方法");//2

Student s1 = new Student();
Student s2 = new Student();
}
}

运行结果：