温故而知新-----三、面向对象--静态

概念：是相对面向过程而言

面向对象和面向过程都是一种思想

面向过程：强调的是功能行为

面向对象：将功能封装进对象，强调具备了功能的对象

面向对象是基于面向过程的

人开门：名词提炼法

人

{

开门（门）

{

门.开（）；

}

}

门

{

开（）{操作门轴等。}

}

再来几个例子方便理解：

面向对象设计把握一个重要的经验：谁拥有数据，谁就对外提供操作这些数据的方法。

再牢牢记住几个案例：人在黑板上画圆 person，blackboard，circle

draw() //是circle的方法

{

x,y—>circle

}

列车司机紧急刹车 //刹车也是车的方法，人只是发布命令让车刹车

售票员正在统计售货小票的金额 //统计金额也是小票的方法

“两块石头磨成一把石刀，石刀可以砍树，砍成木材，木材做成椅子”

Stone //石头不能提供方法把自己变没了

···StoneKnife = KnifeFactory.createKnife(stone);

StoneKnife

···Material = StoneKnife.cut(tree)

Tree

···Chair = ChairFactory.makeChair(material)

Chair

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

以后开发：其实就是找对象使用。没有对象，就创建一个对象

找对象，建立对象，使用对象。维护对象的关系。

类和对象的关系：

类就是：对现实生活中事物的描述。

对象是：这类事物，实实在在存在的个体。

现实生活中的对象：张三 李四

想要描述：提取对象中共性内容。对具体的抽象

描述时：这些对象的共性有：姓名，年龄，性别，学习java功能。

映射到java中，就是class定义的类。

具体对象就是对应java在堆内存中用new建立的实体。

属性对应是类中变量，行为对应的类中的函数（方法）

其实定义类，就是在描述事物，就是在定义属性和行为。属性和行为共同称为类中的成员（成员变量，成员方法）。

作用范围：

成员变量：成员变量作用于整个类中

局部变量：局部变量作用于函数中或语句中

在内存中的位置：

成员变量：在堆内存中，因为对象的存在，才在内存中存在

局部变量：存在栈内存中

匿名对象

匿名对象使用方式之一：当对对象的方法只调用一次时，可以用匿名对象来完成，这样写比较简化

如果对一个对象进行多个成员调用，必须给这个对象起个名字

匿名对象使用方式之二：可以将匿名对象作为实际参数进行传递。

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

好处：将变化隔离、便于使用、提高重用性、提高安全性。

封装原则：将不需要对外提供的内容都隐藏起来，把属性都隐藏，提供公共方法对其访问

/*
private:私有，权限修饰符：用于修饰符类中的成员（成员变量，成员函数）
将age私有化以后，类以外即使建立了对象也不能直接访问
但是人应该有年龄，就需要在Person类中提供对应访问age的方式

注意：私有仅仅是封装的一种表现形式。

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

class Person
{
private String name;
private int age;

//对不同函数进行初始化
Person()
{
System.out.println("A:name = "+ name+",,age = "+age);
}
Person(String n)
{
System.out.println("B:name = "+ name+",,age = "+age);
}
Person(String n,int a)
{
name = n;
age = a ;
System.out.println("C:name = "+ name+",,age = "+age);
}
}

class  Demo
{
public static void main(String[] args)
{
Person p = new Person();
p.setAge(20);
p.speak();
}
}

构造函数：

1、函数名与类名相同

2、不用定义返回值类型

3、不可以写return语句

作用：

给对象进行初始化。

注意：

1、默认构造函数的特点。

2、多个构造函数时以重载的形式存在的

对象一建立就会调用与之对应的构造函数、

构造函数的作用：可以用于给对象进行初始化。

this :看上去，是用于区分局部变量和成员变量同名的情况

this为什么可以解决这个问题？

this到底代表的是什么呢？

this：就代表本类的对象

this代表它所在函数所属对象的引用。

简单说：哪个对象调用this所在的函数，this就代表哪个对象

this的应用：当定义类中功能时，该函数内部要用到调用该函数的对象时，这时用this来表示这个对象

this 语句只能定义在第一行

/*
需求：给人定义一个用于比较年龄是否相同的功能，也就是是否是同龄人

*/
class Person
{
private String name;
private int age;

Person(String name)
{
this.name = name;
}
Person(int age)
{
this.age = age;
}
Person(String name,int age)
{
//this.name = name;
//this.age = age;
this(name);
this.age = age;
}

public void speak()
{
System.out.println("neme="+name+"....age="+age);
}
public boolean compare(Person p)
{
return this.age == p.age;
}
}
class Demo2
{
public static void main(String[] args)
{
Person p1 = new Person(20);
Person p2 = new Person(19);
boolean b = p1.compare(p2);
System.out.println(b);
}
}

static(静态) 关键字

/*

/*

静态:static

用法：是一个修饰符，用于修饰成员（成员变量）

静态修饰内容被对象所共享

当成员被静态修饰后，就多了一个调用方式，除了被对象调用外，还可以直接被类名调用

类名.静态成员 Person.country

static特点：

1、随着类的加载而加载

也就是：静态会随着类的消失而消失
4000
，生命周期最长

2、优先于对象存在

明确一点：静态是先存在，对象是后存在

3、被所有对象所共享

4、可以直接被类名所调用

实例变量和类变量的区别：

1、存放位置：

类变量随着类的加载而存在于方法区中

实例变量随着对象的建立而存在于堆内存中

2、生命周期：

类变量生命周期最长，随着类的消失而消失。

实例变量生命周期随着对象的消失而消失

静态使用注意事项：

1、静态方法只能访问静态成员。

非静态方法可以访问静态成员

2、静态方法中不可以定义this、super关键字

因为静态优先于对象存在。所以静态方法中不可以出现this

优点：对对象的共享数据进行单独空间的存储，节省空间，没有必要每一个对象中都存储一份

可以直接被类名调用

缺点：生命周期过长

主函数时静态的

*/

class Person

{

String name;

static String country = “CN”;

public void show()

{

System.out.println(name+”::”+country);

}

}

class Demo

{

public static void main(String[] args)

{

//Person p = new Person();

//p.name = “zhangsan”;

//p.show();

System.out.println(Person.country);

}

}

*/

/*

/*

public static void main(String[] args)

主函数：是一个特殊函数，作为程序的入口，可以被jvm调用

主函数的定义：

public：代表着该函数访问权限是最大的。

static：代表主函数随着类的加载就已经存在了。

void：主函数没有具体的返回值。

main不是关键字，但是是一个特殊的单词，可以被jvm识别

函数的参数：（String[] args）：函数的参数，参数类型是一个数组，该数组中

的元素是字符串，字符串类型的数组。

主函数是固定格式的：jvm识别。

jvm在调用主函数时，传入的是new String[0]

*/

/*

什么时候使用静态？

要从两方面下手：

因为静态修饰的内容有成员变量和函数。

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

当对象中出现共享数据时，该数据被静态所修饰

对象中的特有数据要定义成非静态存在于堆内存中

什么时候定义静态函数？

当功能内部没有访问到非静态数据（对象的特有数据）

那么该功能可以定义成静态的

*/

/*

一个类中默认会有一个空参数的构造函数。

这个默认的构造函数的权限和所属类一致

如果类被public修饰，那么默认的构造函数也带public修饰符

如果类没有被public修饰，那么默认的构造函数，也没有public修饰

静态代码块、构造代码块、构造函数同时存在时的执行顺序：静态代码块 –>构造代码块 –> 构造函数；

成员变量先于构造代码块