面向过程：当需要实现一个功能的时候，每一个具体的步骤都要亲力亲为，详细处理每一个过程
面向对象：当需要实现一个功能的时候，不关心具体的步骤，而是找一个已经具有该功能的人，来帮我做事
面向过程
public class face {
public static void main(String[] args) {
int[] array = {10,20,30,40,50};
//打印格式为[10,20,30,40,50]
//使用面向过程，每一个步骤亲力亲为
System.out.print("[");
for (int i = 0; i < array.length; i++) {
if (i == array.length - 1) {
System.out.println(array[i] + "]");
}else{
System.out.print(array[i] + ",");
}
}
}
}
面向对象
import java.util.Arrays;
public class face {
public static void main(String[] args) {
int[] array = {10,20,30,40,50};
//打印格式为[10,20,30,40,50]
//使用面向过程
System.out.print("[");
for (int i = 0; i < array.length; i++) {
if (i == array.length - 1) {
System.out.println(array[i] + "]");
}else{
System.out.print(array[i] + " ,");
}
}
System.out.println("=============================");
System.out.println(Arrays.toString(array));
//使用面向对象
//找一个JDK给我们提供好的Arrays类
//其中有一个toString方法，直接就能把数组变成想要的格式的字符串
}
}
面向对象思想是一种更符合我们思考习惯的思想，它可以将复杂的事情简单化，并将我们从执行者变成了指挥者。
面向对象的语言中，包含了三大基本特征，即封装，继承和多姿
类
类：是一组相关属性和行为的集合，可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该类事物
属性：就是该物的状态信息 eg：名字，体重，年龄，颜色
行为：就是该事物能够干什么 eg：走，跑，叫
package javalx;
public class student {
String name;
int age;
public void eat(){
System.out.println("吃饭饭！");
}
public void sleep(){
System.out.println("睡觉觉!");
}
public void study(){
System.out.println("学习！");
}
}
注意事项
1.成员变量是直接定义在类当中的，在方法外边
2.成员方法没有static关键字
通常情况下，一个类并不能直接使用，需要根据创造一个对象，才能使用
1.导包：也就是指出需要使用的类，在什么位置
import 包名称.类名称 eg：上面代码 import lxjava.student;
对于和当前类属于同一个包的情况，可以省略导包语句不写
2.创建
类名称 对象名 = new 类名称（）；
Student stu = new Student（）；
3.使用 ，分为两种情况
使用成员变量：对象名.成员变量名
使用成员方法：对象名.成员方法名
想用谁，就用对象名点儿谁
类与对象的关系
类是对一类事物的描述，是抽象的
对象是一类事物的实例，是具体的
类是对象的模板，对象是类的实体
package javalx;
public class DemoStudent {
public static void main(String[] args) {
Student stu = new Student();
System.out.println(stu.age);//0
System.out.println(stu.name);//null
stu.name = "赵丽颖"；
stu.age = 18;
System.out.println(stu.age);//18
System.out.println(stu.name);//赵丽颖
stu.eat();//吃饭饭！
stu.study();//学习！
}
}
注意事项
如果成员变量没有进行赋值，那么将有一个默认值，规则和数组一样
package demo01;
public class Phone {
String brand;
int prince;
String color;
public void call(String who) {
System.out.println("给"+who+"打电话");
}
public void message(){
System.out.println("群发短信");
}
}
package demo01;
public class Demo01Phone {
public static void main(String[] args) {
//根据phone类，创建一个名为one的对象
//格式，类名称 对象名 = new 类名称（）；
Phone one = new Phone();
one.brand = "华为";
one.prince = 9000;
one.color = "银色";
System.out.println(one.brand);
System.out.println(one.prince);
System.out.println(one.color);
one.call("任正非");
one.message();
}
}
封装
private关键字
是一个权限修饰符
是可以修饰成员（成员变量和成员方法）
作用是保护成员不被别的类使用，被private修饰的成员只在本类中才能访问
针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作
提供“get变量名（）”方法，由于获取成员变量的值，方法用public修饰
提供“set变量名（参数）”方法，用于设置成员变量的值，方法用public饰
private关键字的使用
package javalx;
public class Student {
String name;
// int age;
private int age;
public void setAge(int a){
age = a;
}
public int getAge() {
return age;
}
public void eat(){
System.out.println("吃饭饭！");
}
public void sleep(){
System.out.println("睡觉觉!");
}
public void study(){
System.out.println("学习！");
}
}
package javalx;
public class DemoStudent {
public static void main(String[] args) {
Student stu = new Student();
System.out.println(stu.getAge());
System.out.println(stu.name);
stu.name = "刘海洋";
stu.setAge(30);
System.out.println(stu.getAge());
System.out.println(stu.name);
stu.eat();
stu.study();
stu.sleep();
}
}
this关键字
this修饰的变量用于指代成员变量
方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量
方法的形参没有与成员变量同名，不带this修饰的是成员变量
this:代表所在类的对象引用
方法被那个对象调用，this就代表哪个对象
package javelx;
public class Student {
private String name;
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
// int age;
private int age;
public void setAge(int a){
age = a;
}
public int getAge() {
return age;
}
public void eat(){
System.out.println("吃饭饭！");
}
public void sleep(){
System.out.println("睡觉觉!");
}
public void study(){
System.out.println("学习！");
}
}
package javalx;
public class DemoStudent {
public static void main(String[] args) {
Student stu = new Student();
stu.setName("LIUEUX");
stu.setAge(19);
System.out.println(stu.getAge());
System.out.println(stu.getName());
stu.eat();
stu.study();
stu.sleep();
}
}
封装
1.概述：
是面向对象的三大特征之一（封装，继承，多态）
是面向对象编程语言对客观世界的模拟，客观世界里的成员变量都是隐藏在对象内部的，外界无法操作
2.封装原则
将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问
成员变量private，提供对应的getXxxv（）/setXxx()方法
3.封装的好处
通过方法来控制成员变量的操作，提高了代码的安全性
把代码用方法进行封装，提高了代码的复用性
构造方法
构造方法概述
构造方法是一种特殊的方法
作用：创建对象
格式：
public class 类名{ public class Student {
修饰符 类名（参数）{ public Student() {
//构造方法内书写的内容 //构造方法内书写的内容
} }
} }
功能：主要完成对象数据的初始化
package demo02;
public class Student{
private String name;
private int age;
public Student() {
System.out.println("无参构造方法");
}
public void show() {
System.out.println(name+","+age);
}
注意事项
标准类的制作
1.成员方法
使用private修饰
2.构造方法
提供一个无参构造方法
提供一个带多个参数的构造方法
3.成员变量
提供每一个成员变量对应的setXxx（）/getXxx（）
提供一个显示对象信息的show（）
4.创建对象并为其成员变量赋值的两种方式
无参构造方法创建对象后使用setXxxv（）赋值
使用带参数构造方法直接创建带有属性值的对象
public class Student{
private String name;
private int age;
public Student() {}
public Student(String name,int age) {
this.name = name;
this.age = age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
public void show() {
System.out.println(name+","+age);
}
}
package demo02;
public class StudentDemo02 {
public static void main(String[] args) {
Student s1 = new Student();
s1.setName("林青霞");
s1.setAge(30);
s1.show();
Student s2 = new Student("林青霞",30);
s2.show();
}
}
