面向对象

面向对象

一，面向对象的概念：

1，理解面向对象

●面向对象是相对面向过程而言的

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

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

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

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

2，面向对象的特点

●是一种符合人们思考习惯的思想

●可以将复杂的事情简单化

●将程序员从执行者转换成了指挥者

●完成需求时：

①先要去找具有所需功能的对象来用。

②如果该对象不存在，那么创建一个具有所需功能的对象。

③这样简化开发并提高复用。

3，面向对象开发，设计，特征

●开发的过程：其实就是不断的创建对象，使用对象，指挥对象做事情。

●设计的过程：其实就是在管理和维护对象之间的关系。

●面向对象的特征：

①封装（encapsulation）

将对象的属性和行为封装起来，不需要让外界知道具体实现细节，这就是封装思想。

②继承（inheritance）

描述的是类与类之间的关系。

③多态（polymorphism）

在程序中允许出现重名现象。

二，类与对象的关系

●使用计算机语言就是不断的在描述现实生活中的事物。

●java中描述事物通过类的形式体现，类是具体事物的抽象，概念上的定义。

●对象即是该类事物实实在在存在的个体。

1，类与对象（图例）

●类与对象的关系图：

●类就是图纸--------汽车就是堆内存中的对象

2，类的定义

●生活中描述事物无非就是描述事物的属性和行为。

×如：人有身高，体重等属性，有说话，运动等行为。

●Java中用类class来描述事物也是如此

×属性：对应类中的成员变量。

×行为：对应类中的成员函数。

●定义类其实是在定义类中的成员（成员变量和成员函数）。

3，成员变量和局部变量的区别

●成员变量：

×成员变量定义在类中，在整个类中都可以被访问。

×成员变量随着对象的建立而建立，存在于对象所在的堆内存中。

×成员变量有默认初始化值。

●局部变量：

×局部变量只定义在局部范围内，如：函数内，语句内等。

×局部变量存在于栈内存中。

×作用的范围结束，变量空间会自动释放。

×局部变量没有默认初始化值。

4，创建对象，使用对象

例如：/面向对象；三个特征；封装，继承，多态。


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


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


/*
类和对象的关系。


现实生活中的对象；张三  李四。
想要描述；提取对象中共性内容，对具体的抽象。
描述时；这些对象的共性有；姓名，年龄，性别，学习java功能。


映射到java中就是class定义的类。
具体对象就是对应java在堆内存中用new建立的实体。




类就是；对现实生活中事物的描述。
对象；就是这类事情，实实在在存在的个体。
*/


//需求；描述汽车。其实就在是描述事物的属性和行为。
//属性对应是类中变量，行为对于类中的函数（方法）。
//其实定义类，就是在描述事物，就是在定义属性和行为，属性和行为共同成为类中的成员。


/*
成员变量和局部变量。
作用范围
成员变量作用于整个类中。
局部变量作用于函数中，或语句中。
在内存中的位置；
成员变量；在堆内存中，因为对象的存在，才在内存中存在。
局部变量；存在栈内存中。
*/
class Car
{
//描述颜色
String color = "红色";
//描述轮胎数
int num = 4;
//运行行为
void run ()
{
System.out.println(color+".."+num);
}
}




class CarDemo 
{
public static void main(String[] args) 
{
//生产汽车，在java中通过new操作符来完成。
//其实就是在堆内存产生一个实体。
Car c = new Car();//c就是一个类类型变量。记住；类类型变量指向对象。
//需求；将已有车的颜色改成蓝色，指挥该对象做使用，在java中指挥方式是；对象。对象成员
c.color="blue";
c.run();
Car c1 = new Car();
c1.run();


//匿名对象使用方式之一；当对对象的方法之调用一次时，可以用匿名对象来完成，这样比较简化。
//如果对一个对象进行多个成员调用，必须给这个对象起个名字。 
//匿名对象使用方式二；可以将匿名对象作为实际参数进行传递。


}
//需求；汽车修配厂，对汽车进行改装，将来的车修改成黑色，三个轮胎。


}

5，匿名对象

●匿名对象是对象的简化形式

●匿名对象两种使用情况

×当对对象方法仅进行一次调用时

×匿名对象可以作为世界参数进行传递

三，封装（Encapsulation）

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

●好处：

×将变化隔离

×便于使用。

×提高重用性。

×提高安全性。

●封装原则：

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

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

1，private（私有）关键字

●private关键字：

×是一个权限修饰符。

×用于修饰成员（成员变量和成员函数）

×被私有化的成员只在本类中有效。

●常用之一：

×将成员变量私有化，对外提供对应的set，get方法对其进行访问，提高对数据访问的安全性。

/*
private :私有；权限修饰符；用于修饰类中的成员（成员变量，成员函数）。
私有只在本类中有效。


将age私有化以后，类以外即使建立了对象也不能直接访问。
但是人应该有年龄，就需要在person类中提供对应访问age的方式。
*/
class Person
{
private int age;
public void setAge(int a)
{
age = a ;
}
void speak()
{
System.out.println("age="+age);
}
}


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

}
}

4，构造函数

●特点：

①函数名与类名相同

②不用定义返回值

③不可以写return语句

●作用：

给对象进行初始化。

●注意：

①默认构造函数的特点。

②多个构造函数是以重载的形式存在的。

例如：class Demo1 
{
public static void main(String[] args) 
{
Person p1 = new Person(12);//实例化Person对象。

p1.speak();


}
}
class Person
{
private int age;

//定义有参数构造方法。
public  Person(int a)
{
age = a;

}
void speak()
{
System.out.println("我今年"+age+"岁了。");
}

5，this关键字

特点：this代表其所在函数所属对象的引用。

换言之：this代本类对象的引用。

什么时候使用this关键字呢？

当在函数内需要用到调用该函数的对象时，就用this。

例如：/*
this;看上去，是用于区分局部变量和成员变量同名情况。
this为什么可以解决这个问题呢？
this到底代表的是什么呢？


this；就代表本类的对象，到底代表那一个呢？
this代表他所在函数所属对象的引用。
简单说；哪个对象在调用this所在函数，this就代表哪个函数。
this 只能是构造函数的第一行。初始化动作要先执行。


*/


class person


{
private String name;
private int age;
person (int age)
{
this.age=age;
}


person(String name)
{
this.name = name;
}
person(String name,int age)
{
//this.name = name;
this(name);
this.age = age;
}
public void speak()
{
System.out.println("name="+this.name+"...age="+this.age);
show();
}
public void show()
{
System.out.println(this.name);
}
/*
需求；给人定义一个用于比较年龄是否相同的功能。也就是是否是同龄人。
*/

6，static（静态）关键字

●static 关键字：

×用于修饰成员（成员变量和成员函数）

●被修饰后的成员具备以下特点：

×随着类的加载而加载

×优先于对象存在

×被所有对象所共享

×可以直接被类名调用

●使用注意

×静态方法只能访问静态成员

静态方法中不可以写this，super关键字

×主函数是静态的

例：/*
静态；static。
用法：是一个修饰符，用于修饰成员（成员变量，成员函数）。
当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，
还可以直接被类名调用。类名。静态成员


static特点：
1.随着类的加载而加载。
也就是说静态会随着类的消失而消失。说明它的生命周期最长。
2.优先于的对象存在。
明确一点：静态是先存在的，对象是后存在的。


3.被所有对象所共享。
4.可以直接被类名所调用。


实例变量和类变量的区别：
1.存放位置。
类变量随着类的加载而存在于方法区中。
实例变量随着对象的建立而存在于敦内存中。
2.生命周期：
类变量生命周期最长，随着类的消失而消失。
实例变量生命周期随着对象的消失而消失。




静态的使用注意事项；
1.静态方法只能访问静态成员。 
非静态方法即可以访问静态也可以访问非静态
2.静态方法中不可以定义this，super关键字。
因为静态优先于对象存在，所以静态方法中不可以出现this。
3.主函数是静态的


静态有利有弊
利：对对象的共享数据进行单独空间的存储，节省空间。没有必要每一个对象中都存储一份。
可以直接被类名调用。
弊：生命周期过长。
访问出现局限性。（静态虽好，只能访问静态。）




*/


class person
{
String name;//成员变量，实例变量。
static String country = "CN";//静态的成员变量，类变量。
public void show ()
{
System.out.println(name+"::::"+country);
}
}
class StaticDemo 
{
public static void main(String[] args) 
{
//person p = new person();
//p.name = "zhangsan";
//p.show();


//System.out.println(p.country);
System.out.println(person.country);
}
}