面向对象

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

比如，有如下三个人，每个人都有自己的功能：使用伪码体现

张三{

Public void 部署程序(){

System.out.println("部署java程序");

}

}

李四{

Public void 写代码(){

System.out.println("写java代码")

}

}

老板{

Public static void main(String[] args){

李四.写代码();

张三.部署程序 ();

...

}

}

从以上的概述可以得出这样的结论：

面向过程：强调的是过程，每个过程及实施都要自己一步一步去实施，考虑的事情比较多

例：首先学习Java语法，然后编写Java程序，然后编译，运行其中的每个细节都要自己去实施；

面向对象：强调的是对象，需要某些功能的时候，去找具有这样功能的对象，然后由对象去调用功能

例：知道张三会写Java程序，去找张三，让张三写程序，把结果交给我只需要找人去干活，然后等待结果即可。

面向对象思想的特点

是一种更符合我们思想习惯的思想

可以把事情更加简单化，不必考虑事情的每一个细节，只在宏观把握

将我们从执行者变成了指挥者

类和对象

对象:可以理解成具有某些功能的综合体

类：同一种事物的抽象，将他们的共同属性和行为抽象出来

面向对象的编程过程：实际上就是不断的编写各种“类”，然后利用类去创建对象，再使用对象，指挥对象完成功能

Java中的类：

有成员变量对这个类的属性进行描述；有成员方法对这个类的行为进行模拟。

成员变量 -- 类的属性

成员方法 -- 类的功能

总结Java中的类和对象

类：一组相关的变量和方法的结合，是一个抽象的概念

对象：是类实例化创建出来的，是“类”这个概念的具体表现形式

举例

学生(类)：是一个类，它是一个抽象的概念，有学号，姓名，年龄等属性；有学习，写作业等行为的都属于学生，不是指的某一个个体

张三(对象)：是学生类的一个具体对象，他是一个学生，具有学生的属性和行为

类的定义

定义一个学生类

public class Student {

//成员变量，学生类的属性

public String name; //成员变量是有默认值的，引用数据类型，默认为null

public int age; //0

public String address;

//成员方法，学生类的行为

public void study(){

System.out.println("study");

}

public void eat(){

System.out.println("eat");

}

public void sleep(){

System.out.println("sleep");

}

}

定义一个手机类

public class Phone {

//成员变量，手机类的属性

public String brand; //成员变量是有默认值的，引用数据类型，默认为null

public int price;

public String color;

//成员方法，手机类的功能

public void call(String name){

System.out.println("给"+name+"打电话");

}

public void sendMessage(){

System.out.println("发短信");

}

}

类的使用

创建对象

类名 对象名 = new 类名()；

使用对象的变量或者方法

对象名.成员变量；

对象名.成员方法；

定义一个测试类对上面学生类进行测试

定义测试类，这个类主要是用来存放main方法，让JVM执行，不是用来创建对象用的

import home.Student;

public class StudentTest {

public static void main(String[] args) {

//类名 对象名 = new 类名();

Student stu = new Student();

//输出成员变量值

System.out.println(stu.name);

System.out.println(stu.age);

System.out.println(stu.address);

//给成员变量赋值

stu.name = "张三";

stu.age = 24;

stu.address = "北京昌平";

//重新输出成员变量值

System.out.println(stu.name+stu.age+stu.address);

//调用方法 对象名.方法名

stu.study();

stu.eat();

stu.sleep();

}

}

定义一个测试类对上面手机类进行测试

public class PhoneTest {

public static void main(String[] args) {

//创建手机对象

//类名 对象名 = new 类名();

Phone p = new Phone(); //直接输出成员变量值

System.out.println(p.brand+" "+p.price+" "+p.color);

//给成员变量赋值

p.brand = "apple";

p.color = "gold";

p.price = 5000;

System.out.println(p.brand+" "+p.price+" "+p.color); //再次输出

//调用方法

p.call("张三");

p.sendMessage();

}

}

1个Phone对象的内存图及初始化过程

Phone p = new Phone();

Phone p这一步实在栈空间内开辟空间，也叫压栈；new Phone()这一步加载Phone.class文件，同时在堆中开辟内存空间；

sop(p.brand + " " + p.price + " " + p.color)这一步是将实例变量显示初始化值；

p.brand = "三星"； p.price = 3999; p.color= "白色" 这三步是给实例变量赋值并覆盖初始值；

p.call("乔布斯")；p.sendMessage();p.playGame(); 这三步实在调用成员方法；

首先定义main方法，main方法储存在方法区的静态区，加载Phone。class文件创建对象Phone p 进行压栈，new Phone在堆中开辟空间并给成员变量初始化值，给成员变量重新赋值，再之后通过main方法中的对象p来调用成员方法，并进行压栈，方法执行完毕后进行弹栈。

实例变量与局部变量

定义：

实例变量：属于类的实例对象，没有static修饰的，目前接触到的成员变量都是实例变量

局部变量：属于方法的变量，只在方法内有效

区别：

在类中的位置不同

实例变量 在类中，并且在方法外定义

局部变量 方法内或者方法声明上(形参)定义

在内存中的位置不同

实例变量 堆内存(属于对象)

局部变量 栈内(属于方法)

生命周期不同

实例变量 随着对象的存在而存在，随着对象的消失而消失

局部变量 随着方法的调用而存在，随着方法的调用完毕而消失

初始化值不同

实例变量 有默认的初始化值(0/false/null)

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

形式参数

基本类型作为形式参数：传值，实际上就是把实参的值拷贝一份给形参，形参不论怎么改动，都不会影响到实参的值

引用类型作为形式参数：传递的是实参所指向的实例对象或者数组，即：传递的是实参的引用(地址值)，形参和实参具有相同的引用，所以，形参对引用的改动能立即从实参上看到

public class Demo1{

public int sum(int a ,int b){

return a+b;

}

public void show(){

System.out.println("学习");

}

}

测试类

public class DemoTest {

public static void main(String[] args) {

Demo1 d = new Demo1();

System.out.println(d.sum(5, 6));

d.show();

}

}

封装

封装概述

封装是面向对象编程的三个重要特征之一，其余两个是多态和继承。

封装指的是隐藏对象的属性和实现细节，不允许外部直接访问对象的内部信息，而是通过该类提供的方法来实现对内部信息的访问。

为了实现良好的封装，需要从以下两个方面来考虑

把对象的实例变量和实现细节隐藏起来，不允许外界直接访问

把方法暴露出来，让方法来控制对这些成员变量进行安全的访问和操作

封装练习

public class StudentDemo1 {

private String name; //封装名字

private int age; //封装年龄

public String getName(){ //通过类内部方法获取变量

return name;

}

public void setName(String name){ //给变量进行赋值

this.name = name;

}

public int getAge(){

return age;

}

public void setAge(int age){

this.age = age;

}

}

测试类

public class StudentDemo1Test {

public static void main(String[] args) {

StudentDemo1 sd1 = new StudentDemo1(); //创建对象

sd1.setName("张三"); //给变量赋值

System.out.println(sd1.getName()); //通过引用方法对变量进行打印

sd1.setAge(25);

System.out.println(sd1.getAge());

}

}

Private 关键字

是一个权限修饰符。

可以修饰成员(成员变量和成员方法)

被private修饰的成员只能本类中才能访问。

面向对象练习

定义一个类Demo,其中定义一个求两个数据和的方法，定义一个测试类Test，进行测试。

public class Demo {

public int num1;

public int num2;

public int getSum1(){

return num1+num2;

}

}

测试类

public class DemoTest {

public static void main(String[] args) {

Demo d = new Demo();

d.num1 = 10;

d.num2 = 20;

System.out.println(d.getSum1());

}

}

定义一个长方形类rectangle,定义求周长girth和面积area的方法，然后定义一个测试类Test2，进行测试。

public class Rectangle {

public int a; //长方形的长

public int b;//长方形的宽

//定义方法求边长

public int girth(){

return (a+b)*2;

}

//定义方法求面积

public int area(){

return a*b;

}

}

测试类

import java.util.Scanner; //导包 键盘输入

public class RectangleTest {

public static void main(String[] args) {

Scanner input = new Scanner(System.in);

Rectangle rect = new Rectangle(); //创建对象

System.out.println("请输入长方形的长：");

int a = input.nextInt();

System.out.println("请输入长方形的宽：");

int b = input.nextInt();

rect.a = a; //给成员变量赋值

rect.b = b;

System.out.println("长方形的周长为："+rect.girth());

System.out.println("长方形的面积为："+rect.area());

}

}