06
课程内容
1、面向对象的编程思想
2、类和对象
3、成员变量和局部变量
4、匿名对象
5、封装，构造方法，private关键字
一、面向对象（OOP）
1、面对对象，编程中使用的一种编程思路，编程思想。java，c++
2、面向过程设计和面向对象设计区别实际上就是解决问题方式的不同。
3、面向过程和面向对象都是编程思想，面向过程是面向对象的基础，面向对象是基于面向过程的。
4、面向过程：更强调的是解决问题的基本步骤，强调解决问题的方式，更强调的就是函数。解决一个问题，首先分析出解决问题的步骤，然后用函数把这些步骤一步一步的都给实现，解决的时候就是一个一个函数的调用。
eg：填饱肚子。买菜--》洗菜---》切菜---》起火--》炒菜---》出锅--》吃吃吃---》吃饱了
面向对象：更强调的是解决问题的主体，谁来解决这个问题，更强调的是数据，更强调的是对象，更强调的是谁拥有数据和操作数据的权利。
5、面向对象的好处：
（1）更符合人类的一种思想习惯，遇到问题，找人，找工具，找对象，而不是找方法
（2）复杂问题简单化
（3）由执行者变成了指挥者
6、面对对象的特征：
封装
继承
多态
（抽象）
二、类和对象
1、类：类型，对具体事物的一种抽象的认识。
2、对象：事物的一种具体表现。
类的说明
1、类：是一组相关属性和行为的集合
2、属性：对于事物的描述
java语言中，就是一个成员变量，和以前定义的方式一样。只不过就是位置发生了变化
以前定义在方法中的，现在定义在类中方法外
3、行为：对于事物功能的描述
java语言中，就是一个成员方法。和以前的定义方式一样，只不过修饰符发生了变化
以前修饰符public static ，现在将static去掉
4、eg：
电脑类
属性：品牌，颜色，价格
行为：敲代码，购物，看电影
5、说明
自定义类型在编译之后，也会生成一个字节码文件.class文件
在一个源文件中是可以定义多个类，一旦编译之后，就会生成多个类的字节码文件
package com.ujiuye.demos;
public class Computer {
String brand;
String color;
double price;
public void playCode() {
System.out.println("敲代码");
}
public void shopping() {
System.out.println("购物");
}
public void lookMovie() {
System.out.println("看电影");
}
}
class A{
}
对象的创建和使用
1、对象的创建格式：
类名 对象名 = new 类名();
2、格式内容解释
类名：要创建对象所属的类型，String，Scanner
对象名：是一个合法的标识符即可，本质上也是一个引用变量，存储的是对象在堆内存中开辟出的地址值
new：就是一个关键字，在堆内存中开辟一段内存空间，用于存储该类型的数据。
();表示的是调用一个方法。 构造方法。
3、访问属性
对象名.属性名（访问）
对象名.属性名 = 属性值；（修改）
4、访问方法
对象名.方法名()；
package com.ujiuye.demos;
public class Demo_1 {
public static void main(String[] args) {
Computer com = new Computer();
System.out.println(com.brand);
com.color = "black";
com.price = 50000;
com.price = 150000;
System.out.println(com.color);
System.out.println(com.price);
com.playCode();
com.shopping();
com.lookMovie();
}
}
创建对象的内存理解
1、将要创建的对象的所属类型字节码文件加载到方法区中，形成Car.class字节码文件
2、在栈内存中创建一个Car类型的引用变量，将来用于存储在堆内存中开辟内存的对象地址
3、在对堆内存中开辟的内存空间，给各个成员变量进行分配内存，然后进行默认初始化的赋值
4、将堆内存中对象的地址，赋值给栈内存中声明的该类型的引用变量
说明：
（1）第一次使用Car类型的时候，会将该类型的字节码文件加载到方法区，第二次使用的时候，不需要重复加载
（2）在创建对象的过程中，默认隐含了一个字节码的地址，将来可以通过对象找到创建自己的字节码
（3）那个对象调用方法，方法的栈帧中，就默认隐含了该对象的地址
（4）每次使用new关键字，都会在堆内存中开辟一段内存空间
两个引用指向同一个对象
三、面向对象中的其他内容
成员变量和局部变量
1、成员变量：定义在类中方法外的变量，就是成员变量
局部变量：定义在方法中的变量，就是局部变量
2、不同点：
代码层面：定义的位置不同
局部变量：类中方法中，（方法声明上）
成员变量：类中方法外
内存层面：空间不同
局部变量：属于方法，和方法位置相同，在栈内存方法的栈帧中。
成员变量：属于对象,和对象的位置相同，在堆内存中的对象中。
时间不同：生命周期不同
局部变量：随着方法的调用而存在，随着方法的调用结束而消失
成员变量: 随着对象的创建而存在，随着对象的消失而消失。（栈内存中没有引用指向堆内存中的对象的地址的时候，等待一段时间，对象就会被垃圾回收机制回收。）
初始化状态不同：
局部变量：没有默认的初始化赋值，必须先进行初始化，再使用
成员变量：有默认的初始化值的。
基本的数据类型：
整数类型: 0
小数类型：0.0
布尔类型：false
字符类型：‘\u0000’
引用数据类型：null
package com.ujiuye.demos;
public class Demo_4 {
int a ;
double d;
char c;
String str;
boolean boo;
public static void main(String[] args) {
int b = 20;
Demo_4 demo_4 = new Demo_4();
System.out.println(demo_4.a);
System.out.println(demo_4.d);
System.out.println(demo_4.c);
System.out.println(demo_4.str);
System.out.println(demo_4.boo);
}
}
匿名对象的理解和使用
1、匿名对象：没有名字的对象
2、格式：
new 类名();
3、匿名对象的使用场景
（1）如果某个对象在创建之后，想调用一次该对象中的某个方法，就可以说使用匿名对象。
（2）可以作为某个方法的实际参数
在主方法中，可以将该对象看做是匿名对象，但是在被调用的方法中，这个对象是有引用的对象，不是匿名对象
（3）可以作为某个方法的返回值。
匿名对象作为返回值存在,在被调用者方法中，可以看做是匿名对象，但是在主方法中，不能不是匿名对象了
4、注意事项
匿名对象可以给成员变量赋值吗？
可以赋值，但是赋值完之后，是没有办法访问到的。使用匿名对象进行赋值是没有任何意义的。
package com.ujiuye.pojo;
public class Computer{
public String brand;
public String color;
public double price;
public void playCode() {
System.out.println("敲代码");
}
@Override
protected void finalize() throws Throwable {
System.out.println("我是垃圾对象，我被回收了");
}
public void shopping() {
System.out.println("购物");
}
public void lookMovie() {
System.out.println("看电影");
}
}
class A{
}
package com.ujiuye.demos;
import com.ujiuye.pojo.Computer;
public class Demo_5 {
public static void main(String[] args) {
new Computer();
new Computer().shopping();
new Computer().playCode();
Computer computer = new Computer();
useComputer(new Computer());
Computer c = makeComputer();
new Computer().brand = "华为";
new Computer().brand = "小米";
System.out.println(new Computer().brand);
for (int i = 0; i < 500000; i++) {
new Computer();
}
}
public static Computer makeComputer() {
return new Computer();
}
public static void useComputer(Computer com) {
com.brand = "apple";
com.price = 89989;
com.shopping();
System.out.println(com.brand + " " + com.price);
}
}
四、封装
1、封装：隐藏事物的属性和实现细节，对外公共的访问方式
2、封装的好处：
隐藏事物的实现细节
提高了代码的安全性
3、封装的原则
隐藏事物的属性
隐藏事物的实现细节
对外提供公共的访问方式
private关键字
1、private：私有的
2、可以修饰的内容：
修饰成员变量
修饰成员方法
修饰构造方法
修饰内部类
3、修饰之后的效果
被private修饰的成员，只能在本类中进行访问
package com.ujiuye.demos;
public class Person {
private String name;
private int age;
public void sleep() {
System.out.println("睡觉");
}
public void show() {
System.out.println(name + " " + age);
}
public void controlAge(int a) {
if(a >= 0 && a <= 120) {
age = a;
}else {
System.out.println("年龄不合法");
}
}
public int getAge() {
return age;
}
}
Getter和Setter
1、当属性被私有之后，外界就无法直接访问，所以需要提供公共的方法方式，让外界可以间接的访问属性。对于当前类，就可以控制外界访问属性的方式。（我让你怎么访问，你就怎么访问）
2、一般提供get方法，获取成员变量的值，提供set方法，设置成员变量的值。
3、eg: getName() setName(),getAge(),setAge();
package com.ujiuye.demos;
public class Student {
private String name;
private int age;
public void setName(String n) {
name = n;
}
public String getName() {
return name;
}
public void setAge(int a) {
age = a;
}
public int getAge() {
return age;
}
}
变量的访问原则和this关键字
1、变量的访问原则：就近原则
2、变量的定义，声明：带着数据类型的变量
变量的使用，访问：不带数据类型的变量
3、就近原则：
当在访问某个变量名称的时候，会先寻最近的该变量的名称的定义，如果找到了，就使用该变量，如果没有找到，才会到更远的位置寻找该变量的定义。
当局部变量和成员变量同名的时候，一定是先使用局部变量中声明的变量，如果没有，才会使用成员变量位置定义的变量
4、this关键字
表示当前类型当前对象的引用
那个对象调用this所在的方法，this就代表那个对象
作用：用于区分局部变量和成员变量同名的情况，使用this.属性名一定就是成员变量
没有使用this.变量名 ，根据就近原则来判断的。
package com.ujiuye.demos;
public class Demo_8 {
public static void main(String[] args) {
Teacher t = new Teacher();
t.setName("张雪峰");
System.out.println(t.getName());
}
}
class Teacher {
private String name = "马云";
private int age;
public void setName(String name) {
System.out.println(name);
System.out.println(this.name);
this.name = name;
System.out.println(name);
}
public String getName() {
return name;
}
public void setAge(int a) {
age = a;
}
public int getAge() {
return age;
}
}
构造方法概述
1、构造方法，构造函数，构造器
2、构造方法：用于给成员变量进行赋值。在创建对象的时候，自动调用构造方法，等对象创建完成之后，对象中的成员变量就已经有指定值了
3、构造方法的定义格式
修饰符 方法名称(参数列表){
方法体;
}
4、格式的说明：
（1）方法名称：必须和类名一模一样，连大小写都一样
（2）构造方法没有返回值类型的，连void都没有
（3）构造方法没有return语句，如果一定要写，可以写return;
5、注意：
（1）构造方法，没有办法进行手动调用，只能有jvm在创建对象的时候调用一次
（2）对象本身不能调用构造方法
（3）构造方法只在创建对象的时候，调用一次
package com.ujiuye.demos;
public class Demo_9 {
public static void main(String[] args) {
Animal animal = new Animal("dog",3);
Animal animal1 = new Animal("dog",5);
System.out.println(animal.getName());
System.out.println(animal.getAge());
System.out.println(animal1.getName());
System.out.println(animal1.getAge());
}
}
class Animal {
private String name;
private int age;
public Animal(String name,int age) {
this.name = name;
this.age = age;
}
public void setName(String n) {
name = n;
}
public String getName() {
return name;
}
public void setAge(int a) {
age = a;
}
public int getAge() {
return age;
}
}
4585
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
