07_Java基础_堆栈、面向对象/过程、封装/构造函数

------- android培训、java培训、.net培训、IOS培训
期待与您交流！ -------

堆栈

任何一个应用程序，在内存中运行之前必须要先进性空间的划分。
比如我们启动了qq，那么就会在内存中分配一片区域来供qq运行使用。
启动了Java，那么就会在内存中为Java程序划分一片空间供其使用。

而在划分的这一片空间中，还需要进行划分，而划分后的每片内存中，对数据的处理方式不一样。

Java对内存空间的划分，分为五部分，分为：栈，堆，方法区，本地方法区，寄存器。

其中寄存器是给cpu用的，这里不多讲。
本地方法区和系统底层的方法相关，这里只做简单介绍。
栈，堆，方法区 三片内存空间是我们需要重点掌握的。

栈内存：存储的都是局部变量（只要是在方法中定义的变量都是局部变量）。一旦变量的生命周期结束，该变量就被释放。

堆内存：存储的都是实体（对象）。凡是用new创建的，都在堆里面。
每一个实体都有一个首地址值。
对内存中的变量都有一个默认初始化值。具体初始值是多少，不同类型的变量不一样。
当实体不再被使用时，就会白垃圾回收机制回收。

int[] arr = new int[3]; 内存图如下：



int[] arr = new int[3];
int[] xxx = new int[3];
arr[1] = 34;
xxx[0] = 89;
内存图如下：

面向对象/过程

什么叫面向过程：其实就是通过函数体现，并不断的调用函数，执行完过程就行了。

什么叫面向对象：将面向过程中的功能进行封装，面对的是封装了功能的实体，这就是面向对象。

面向对象基于面向过程，将过程进行对象的封装。

只要找到了对象，就可以使用对象中的功能。

结论：以后开发，先找对象以及对象的功能，如果没有，自己先创建对象，然后将所需要使用的功能封装到该对象中。

封装/构造函数

匿名类

Car c = new Car();

c.run();

上面两句话可以简化成下面这句：
new Car().run();
这里的对象是没有名字的，这就是匿名对象。

凡是简化了的，通常都是有局限的。

这里的局限就是：new Car().run(); 这句话一执行完，创建的对象就变成了垃圾。

那么匿名对象什么时候用呢？

匿名对象的使用是为了简化书写，当需要对对象的方法进行调用且只调用一次时，可以简化成匿名对象来书写。

Car c = new Car();c.run(); ---> new Car().run();

但是，

Car c = new Car();

c.color = "blue";

c.run();

c.run();

c.run();

是不可以简化成一下书写的。因为对象不同。

new Car().color = "blue";

new Car().run();

new Car().run();

new Car().run();

记住：当对象需要调用多次成员时，不可以简化成匿名对象调用。

匿名对象可以作为参数进行传递：

Car c = new Car();

show(c);

可以简化成如下：

show(new car());

什么是封装

函数就是一个最基本的封装，类也是一个封装体。

封装的好处：
1.提高了代码的服用性。
2.隐藏了实现细节，可以对外提供可以访问的方式，便于调用者的使用。
3.提高了安全性。

面向对象的三个特征：封装，继承，多态。

封装的总结：
类中不需要对外提供访问的内容都私有化，包括属性和行为。
重点：
以后再描述事物，属性都私有化，并提供setXxx getXxx方法对其进行访问。

对变量的访问操作有两个动作：赋值(设置 set)，取值(获取 get)。

构造函数

为了描述事物更准确，发现事物对应的很多对象一创建时，

就有了，一些初始化的数据。在类中该如何完成的。

通过Java中的另一个小技术完成：就是构造函数。对象本身就是构造出来，

构造时，需要做一些动作这些应该定义在函数内。

构造函数（Constructor）有什么用？可以对对象创建进行初始化。

构造函数怎么在代码中体现呢？

1，没有返回值类型。因为构造对象，创建完就结束，需要结果。void也不要写，因为要有区别与一般函数。

2，构造函数名称和类名一致。

3，没有具体的返回值。

接下来，按照以上三点，在Person类中定义一个构造函数。

对象一创建就具备了姓名。

发现了问题？

没有学习构造函数时，对象也创建出来了。那么该对象是否有被构造呢？或者说是否有调用构造函数呢？

是的。必须调用！

那么类中那个构造函数是什么呢？

默认的空参数构造函数。

Person p = new Person();//这就已经调用了Person类中的空参数的构造函数。

类中有定义该构造函数吗？有的。只要定义一个类，

该类中默认就有一个空参数的构造函数，是编译器编译时添加到class文件中。

注意：如果在类中自定义了构造函数，那么默认的空参数构造函数编译器就不添加了。

原理：没有定义对象的初始化过程，编译器会添加一个默认的初始化过程。

如果定义了指定的对象初始化过程，默认的就不添加了。

构造函数的细节：

1，一个类中可以有多个构造函数，它们的存在是以重载的形式体现的。

2，构造函数中也是有return语句的，用于结束初始化动作的。

3，构造函数是否能被private修饰呢？能，作用：其他程序无法创建该类的对象。

构造函数和一般函数的区别？

1，写法不一样。不重要。

2，运行上有差别，对象一创建就会调用对应的构造函数。

一般方法是对象创建后，才会调用所需的一般函数。

问：有了构造函数初始化姓名，那么还需要setName方法吗？

需要，因为对象创建后，如果需要对数据进行修改，可以通过set完成。

3，构造函数在对象创建时，仅调用一次(初始化动作只做一次，而且先执行)。一般方法可以被对象调用多次。

this

当构造函数之间进行互相调用时，该如何解决呢？

构造函数是对象初始化时调用的。

给哪个对象初始化呢？通过this关键字来记录住对象的地址。并通过this来明确被初始化的对象。

在构造函数中调用其他构造函数的格式： this(实参列表);就会调用对应的构造函数。

构造函数相互调用：

class Person
{
private String name;
private int age;
Person()
{

}
//初始化姓名。
private Person(String n)
{

name = n;
}
//初始化姓名和年龄。既然有初始化姓名的动作。直接调用就可以了。
Person(String n,int a)
{

this(n);//调用一个字符串参数的构造函数。注意：调用其他构造函数的语句，
//必须定义在构造函数的第一行。原因：初始化动作要先执行。
//		name = n;
age = a;
}

}

this到底代表什么呢？

this就代表对象，代表哪个对象呢？哪个对象调用了this所在函数，this就代表哪个对象。

this.变量 = 成员变量：

this关键字的另一个作用：

可以用this标识哪个变量是成员变量。这个标识可以省略不写。

但是，当局部变量和成员变量同名时，必须用this.来标识成员变量。

用this标识成员变量：

class Person
{
private String name;
private int age;
Person()
{

}
//初始化姓名。
private Person(String n)
{

name = n;
}
//初始化姓名和年龄。既然有初始化姓名的动作。直接调用就可以了。
Person(String n,int a)
{

this(n);//调用一个字符串参数的构造函数。注意：调用其他构造函数的语句，
//必须定义在构造函数的第一行。原因：初始化动作要先执行。
//		name = n;
age = a;
}

}

static

静态关键字的特点：

1，静态成员优先于对象存在，被对象共享。

2，静态成员可以直接类名调用，多一个调用方式。

3，静态成员所属于类，所以它是随着类的加载而加载，随着类的消失而消失。

静态的主函数：

public static void main(String[] args)

public : 权限最大。

static ：不需要对象。直接用给定的类名就可以访问该函数了。

void : 不需要返回值。

main : 函数名，该名称是固定的。

(String[] args) : 主函数的参数列表：字符串属性类型的参数。

args : arguments :参数。该名称就是一个变量名。

静态成员和静态函数的体现：

class Person
{
//属性：国籍。如果这个程序只限中国人使用，国籍都是中国。
//如果每一个对象中都存储一份中国，不是不行，只是内存浪费。能不能实现这个中国数据的对象共享呢？
//可以的，通过Java中的一个关键字就可以完成。static。这是一个成员修饰符。
static String country = "中国";//显示初始化。这个country的值就不在对象存储了。被对象共享了。
String name;
public static void show()
{
System.out.println(Person.country);
}
}

class PersonDemo5
{
public static void main(String[] args)
{
System.out.println(Person.country);//共享数据在对象之前就已经存在了。可以有另一种调用方式。可以直接被类名调用。
// 静态的成员所属的是类。
Person.show();

}
}

静态变量：

什么时候定义静态变量呢？

当该成员变量的值，每一个对象都一致时，就对该成员变量进行静态修饰。

静态变量和成员变量的区别：

1，所属范围不同。

静态变量所属于类，成员变量所属对象。

静态变量也称为：类变量；成员变量也称为实例变量。

2，调用不同。

静态变量可以被对象和类调用(一般都用类名调用)

成员变量只能被对象调用。

3，加载时期不同。

静态变量随着类的加载而加载。

成员变量随着对象的加载而加载。

4，内存存储区域不同。

静态变量存储在方法区中。

成员变量存储在堆内存中。

静态变量实例：

class Circle
{
private double radius;//圆的半径。
private static double pi = 3.14;//每一个圆对象中都存储一份，有点浪费内存空间。实现对象的共享。加入静态关键字修饰。
Circle(double radius)
{
this.radius = radius;
}
//获取圆的面积。
double getArea()
{
return radius*radius*pi;
}
static void show()
{
System.out.println("circle show run.."+pi);
}
}

构造代码块：

用于给所有的对象初始化。很少用并很少见。

构造代码块的体现：

class Demo
{
int x = 4;//成员变量 1，默认初始化，2，显示初始化。
{// 构造代码块。只要创建对象就会被调用。给所有对象初始化，构造函数只给对应的对象针对性的初始化。
//这里面可以定义不同构造函数的共性代码。
System.out.println("code run..."+x);
//		System.out.println("----->hahah");
}

Demo()
{
System.out.println("demo run");
}
Demo(int x)
{
System.out.println("demo run...."+x);
//		System.out.println("----->hahah");
}

}

class ConstructorCodeDemo
{
public static void main(String[] args)
{
new Demo();
new Demo(5);

{//局部代码块,作用：就可以控制局部变量的生命周期。
int x = 5;
System.out.println(" 局部代码块..."+x);
}

System.out.println(" over...");
}
}

静态代码块：

特点：随着类的加载而执行,仅执行一次。

作用：给类进行初始化。

静态代码块的体现：

class Demo
{
static int x = 9;//静态变量有两次初始化。 一次默认初始化，一次显示初始化。
static //静态代码块。在静态变量显示初始化以后在执行。
{
System.out.println("类加载就执行的部..."+x);
}
static void show()
{
System.out.println("show run");
}
}

class StaticCodeDemo
{
public static void main(String[] args)
{
Demo.show();
Demo.show();
}
}

------- android培训、java培训、.net培训、 IOS培训 期待与您交流！
-------