1.面向过程与面向对象
面向过程POP（Process-Oriented Programming）：
强调的是系统的数据被加工处理的过程，数据仅仅作为输入和输出存在，在程序设计中主要以函数或者过程为程序的基本组织方式。比如说，C语言中，数据与处理这些数据的函数是分离的，程序的最小单元是函数。
面向对象（Object Oriented Programming）：
是以对象为中心，将对象的内部组织与外部环境区别开来，将表征对象的内部属性数据与外部隔离开来，其行为与属性构成了一个整体，而系统功能则表现为一系列对象之间的相互作用的序列，能更加形象的模拟或表达现实世界。
| 面向过程：POP: Process-Oriented Programming |
|---|
| 以函数（方法）为最小单位 |
| 以过程，步骤为主，考虑怎么做 |
| 面向对象：OOP: Object Oriented Programming |
|---|
| 以类/对象为最小单位，类包括：数据+方法 |
| 以对象（谁）为主，考虑谁来做，谁能做 |
注意：
面向对象的开发过程：其实就是不断创造对象，使用对象，指挥对象做事情
面向对象的设计过程：就是管理和维护对象之间的关系
2.创建类调用成员方法与成员变量
创建一个人类(定义类中的成员变量与方法）：
public class Person {
//成员变量
String name="张三";
int age=20;
char sex='男';
//成员方法
public void eat(){
System.out.println("吃饭");
}
public void sleep(){
System.out.println("睡觉");
}
public void playGame(){
System.out.println("玩游戏");
}
}
public class MyTest {
public static void main(String[] args) {
//我们定义好了一个Person类，就是要使用他里面的属性 和功能
//那么我们如何来使用这个类中的属性和功能呢？
//类，本身他是一个抽象的概念。
//我说人类，理解很抽象，
//我一说具体的张三，李四。所以张三，李四，他是人类的具体表现。
//那我们还要使用Java中的类，类本身就是一个抽象的的概念，
//不能直接使用，要使用，就必须对该类进行实例化，
//所谓实例化，就是创建该类的对象。
//怎么来创建该类的对象呢？
//可以使用使用关键字 new 来完成类的实例化
//1.创建该类的对象
Person person=new Person();
// 通过该类的对象，来使用类中的属性和功能
String username= person.name; //调用类中的属性 对象名.成员变量名
int age= person.age;
char sex=person.sex;
System.out.println(username);
System.out.println(age);
System.out.println(sex);
//调用类中的功能
person.eat();
person.sleep();
person.playGame();
System.out.println("===================================");
//一个类可以创建很多他的对象
Person person2 = new Person();
//你可以给成员变量重写赋值
person2.name="王五";
person2.age=30;
person2.sex='女';
System.out.println(person2.name);
System.out.println(person2.age);
System.out.println(person2.sex);
//类中的方法，每一个该类的对象，都可以调用
person2.playGame();
person2.eat();
person2.sleep();
}
}
2.1 一个对象的内存图详解
public class Student {
String name="zhangsan";
int age;
public void eat(){
System.out.println("吃饭");
}
public void sleep(){
System.out.println("睡觉");
}
}
public class MyTest {
public static void main(String[] args) {
Student student = new Student();
student.name="李四";
student.age=24;
System.out.println(student.name);
System.out.println(student.age);
student.sleep();
student.eat();
}
}
2.2 两个对象的内存图详解
public class Student {
String name="zhangsan";
int age;
public void eat(){
System.out.println("吃饭");
}
public void sleep(){
System.out.println("睡觉");
}
}
public class MyTest2 {
public static void main(String[] args) {
Student student = new Student();
System.out.println(student);
student.name="王老虎";
student.age=30;
System.out.println(student.name);
System.out.println(student.age);
System.out.println("=======================");
Student student2 = new Student();
System.out.println(student2);
student2.name="王百万";
student2.age=40;
System.out.println(student2.name);
System.out.println(student2.age);
}
}
2.3 三个对象的内存图详解
public class Student {
String name="zhangsan";
int age;
public void eat(){
System.out.println("吃饭");
}
public void sleep(){
System.out.println("睡觉");
}
}
public class MyTest3 {
public static void main(String[] args) {
Student s1 = new Student();
s1.name="郭富城";
s1.age=50;
Student s2 = new Student();
s2.name="刘德华";
s2.age=40;
Student s3=s1;
s3.name="张学友";
s3.age=30;
System.out.println(s1.name); //张学友
System.out.println(s1.age); //30
System.out.println(s2.name); //刘德华
System.out.println(s2.age); //40
System.out.println(s3.name); //张学友
System.out.println(s3.age); //30
System.out.println(s1);
System.out.println(s2);
System.out.println(s3);
}
}
3.成员变量与局部变量的区别
| 成员变量 | 局部变量 |
|---|---|
| 成员变量:定义在类中，方法外的变量 | 局部变量:定义在方法中或方法声明上的变量（形参） |
| 成员变量：属于对象 | 局部变量属于方法 |
| 成员变量，随着对象的创建，而产生，随着对象的消失而消失 | 局部变量随着方法的调用而产生，随着方法的调用完毕而消失 |
| 成员变量存在内存 | 局部变量存在栈内存 |
| 成员变量，有默认值 | 局部变量，没有默认值，必须赋值才能使用 |
注意：当局部变量与成员变量重名时，变量的范围会采取就近原则
扫描二维码关注公众号，回复：
12362922 查看本文章
4.private关键字
| private关键字特点 |
|---|
| 是一个权限修饰符 |
| 可以修饰成员变量和成员方法 |
| 被其修饰的成员只能在本类中被访问 |
public class Cat {
protected int aa;
public int num;
String sex;
//定义成员变量
private String name;
//private 私有的，是一个权限修饰符，可以修饰成员变量和成员方法，
//被修饰的成员，只能在本类中访问，外界无法直接访问。
//权限修饰符：public（任意地方） > protected > 缺省的> private(本类)
private int age;
public void setAge(int nl){
if(nl>=0&&nl<=15){
age = nl;
}
}
public int getAge(){
return age;
}
public void setName(String mz){
name=mz;
}
public String getName(){
return name;
}
private void catchMouse(){
System.out.println("猫抓老鼠");
}
public void show(){
catchMouse();
}
}
ublic class MyTest {
public static void main(String[] args) {
Cat cat = new Cat();
//对象名.成员变量名 可以给成员变量赋值，也可以获取成员变量的值。
//如果采用 对象名.成员变量名 这种方式，会把一些不合理的数据设置上去，那这不是我们想要的。
//那怎么解决，我们可以把 对象名.成员变量名 这种方式 给他屏蔽调用，不允许用这种方式，来访问成员变量。
/*
cat.name="小花";
cat.age = 50;
System.out.println(cat.name);
System.out.println(cat.age);
*/
cat.setName("胖橘");
cat.setAge(10);
int age = cat.getAge();
System.out.println(age);
String name = cat.getName();
System.out.println(name);
String sex = cat.sex;
int aa = cat.aa;
int num = cat.num;
// cat.catchMouse();
cat.show();
}
}5.this指针
当我们的局部变量和成员变量相同的时候,如果我们不使用this关键字,那么会导致一个问题:就是局部变量隐藏了成员变量的问题
this关键字特点：是当前类的对象引用
简单的记，它就代表当前类的一个对象。谁调用这个方法,那么该方法的内部的this就代表谁
public class MyTest {
public static void main(String[] args) {
Animal animal = new Animal();
System.out.println("调用者的地址值:"+animal);
animal.setName("大象");
animal.setAge(20);
String name = animal.getName();
int age = animal.getAge();
System.out.println(name);
System.out.println(age);
}
}
public class Animal {
private String name;
private int age;
public void setName(String name){
//this 他代表的是该类的一个引用，你可以理解该类的一个对象，他代表哪个对象呢？哪个对象对象调用这个方法，那么方法中的this就代表谁。
System.out.println("放发中的this:"+this);
this.name=name;
//animal.name=name;
}
public void setAge(int age){
System.out.println("放发中的this:" + this);
this.age=age;
//animal.age=age;
}
public String getName(){
return this.name;
}
public int getAge(){
return this.age;
}
}