上一篇幅简单介绍了一下OOP思想，接下来按照总分总的方式跟小伙伴们说一下类和对象的关系
类与对象:
先说结论：
类是一个模板，是抽象的；
对象是一个具体的实例；
1、类
例如我们写的类
修饰符 class 类名{
属性：其实就是之前学的变量，定义在类中方法外，此时叫做成员变量
属性的格式：
数据类型1 变量名1;
数据类型2 变量名2;
数据类型3 变量名3 = 变量值3;
行为：就是之前学的方法，对象行为，成员方法
去掉了之前的static
修饰符 返回值类型 方法名(参数列表){
方法体语句;
return语句;
}
}
-
类里面只有属性和方法，方法也成为行为，可以看出类只具有静态的属性，动态的行为
-
只能有一个public类表示是一个公开的类，可以在不同包下访问该类
-
同一个包内，不能有同名的类
静态的属性
动态的行为
| 举例 | 学生 | 车 |
|---|---|---|
| 属性 | 姓名性别年龄 | 轮胎个数、品牌、价格 |
| 行为 | 是这个类型会做什么，吃饭睡觉打游戏 | 跑 |
2、对象
对象：是类的具体呈现，是一个实实在在存在的事物，能够看的见摸得着
1、男人是类 郑州二七嵩山南路郑州某大学教室，第二排的陈毅 具体的确定的个体
2、树是个类 二七区郑州某大学大门口的左手路口的第一颗树是一个确定的个体
（1）、对象的定义：
使用对象必须依赖于类，没有类就没有对象
格式：类名 对象名 = new 类名();
-
类名：要创建对象的类型，实例化是创建对象的另一个说法，例如Scanner Person
-
对象名：合法的标识符即可
-
=：将对象在堆内存中申请的空间的地址赋值给对象名存储
-
new：在堆内存中开辟空间
-
类名：和前面保持一致
-
():表示一个方法，这个方法叫做构造方法(用来创建对象的方法)
（2）、对象的使用：
对象的创建和使用
必须使用new创造对象：构造器 Person shu=new person
对象的属性 shu.name
对象的方法 shu.sleep（）
（3）、对象的引用
引用类型：基本类型（8）
对象是通过引用来操作的：栈---->堆（地址）
属性；字段field 成员变量
默认初始化
数字；0 0.0
char ；u0000
boolean：false
引用：null
修饰符 属性类型 属性名 = 属性的值！
（4）、调用属性：
对象名.属性名 = 值; 赋值操作
对象名.属性名; 访问属性中的值
（5）、调用方法：
对象名.方法名(实际参数);
对象名.方法名(实际参数);
public class Demo1 {
public static void main(String[] args) {
//public修饰的类一定要和文件名相同，可以不修饰，但是如果修饰一定和文件名相同
Person1 b = new Person1();//创建对象
b.name = "暴书源"; //属性的赋值
b.age = 20;
b.sex = "男";
//属性的访问使用
System.out.println(b.name);
System.out.println(b.age);
System.out.println(b.sex);
//使用方法
b.eat();
b.sleep("王晗");
}
}
//类与类现阶段，都是平级
class Person { //新建一个人类
//属性：其实就是成员变量 定义在类中方法外的变量
String name; //姓名
String sex; //性别
int age; //年龄
//行为 就是之前学习的方法，去掉了static
public void eat(){
System.out.println("吃外卖");
}
public void sleep(String str){
System.out.println("睡" + str);
}
}
//学生类
public class Student {
//属性；字段
//默认值，引用数据类型为null 整数0 小数0.0 字符\u0000 布尔false
String name;//null
int age;//0
//方法
public void study(){
System.out.println(this.name+"在学习");
}
}
//学程序好？对世界进行更好的建模!---宅！
/*
//类实例化后会返回一个自己的对象
//student对象就是一个student类的具体实例！
Student 小明 = new Student();
Student 小红 = new Student();
小明.name="小明";
小明.age=3;
小红.name="小红";
小红.age=5;
System.out.println(小明.name);
System.out.println(小明.age);
System.out.println(小红.name);
System.out.println(小红.age);
* */
--------------------------------------------------------------------
//以下代码说明Java是值传递的
public class Test1 {//值传递
public static void main(String[] args) {
int a =1 ;
System.out.println(a);//输出为1
Demo4.change(a);
System.out.println(a);//输出同样为1
}
public static void change(int a){
a = 10;
}
}
总结
-
类也可以理解为是一个自定义的一个数据类型（它是引用类型的）
-
对象是一个具体的实例
创建一个对象=实例化一个对象=把类实例化
new cat() 创建一只猫
Cat cat1 = new Cat(); 把创建的猫赋值给cat1
Cat cat；//声明
cat =new Cat（）；//创建对象空间
1、创建对象的步骤：
(1) 把创建对象所属的.class文件加载到方法区，形成一个.class的字节码对象
(2) 栈内存中创建对象的引用，用于存储堆内存中申请的对象的地址 栈里面引用堆的内存地址
(3) 在堆内存中开辟空间，给各个成员变量分配空间，并赋初始值。
引用数据类型为null，整数类型为0，小数0.0字符\u0000 布尔类型false
(4) 将堆内存中申请的地址，赋值给栈内存的对象引用
类是一个模板；抽象，对象是一个具体的实例
2、注意事项：
(1) 第一次使用某个类型的时候，会把该类的字节码文件加载到方法区，第二次使用的时候就不用再加载了
(2) 在堆内存中创建对象的时候，内部空间中会有一份该类的字节码文件存储在方法区中的地址
(3) 每个对象在调用自己的对象方法时，该方法内部都会有一个地址，指向这个对象在堆内存中的地址
(4) 每使用一次new，就会创建一个新的对象，都会在堆内存中申请新的空间
(3)成员变量(类里面的变量)和局部变量（方法例的变量）的区别
-
成员变量：
属于对象，对象在堆内存中 有初始化值，系统会自动申请空间并初始化
随着对象的创建存在，随着对象的消失消失，栈内存中的对象的引用被销毁了，对象也不一定立即消失，对象只能通过GC回收
-
局部变量 ：属于方法，随着方法的调用而创建，方法的调用结束而消失运行时进入栈内存 没有默认初始化赋值，不初始化不能用
-
相同点：都是用来存数据的
-
不同点：内存中所处的位置不同 初始化状态不同 生命周期不同，存活的时间不同
public class Test2 {
public static void main(String[] args) {
//如果想要访问属性
//通过对象名.属性名
// System.out.println(m);
//com.ujiuye.test.Man@1b6d3586
//全类名 = 包名 + 类名 + @ + 地址值;
Man m = new Man();
m.name = "书源";
m.age = 22;
m.say();
}
}
//不要在类中定义类
class Man{
//此时作用域在整个类中 成员变量的作用域是在整个类中，而且没有先后顺序
String name;
int age;
public void say(){
System.out.println(name + "~~~~~~" + age);
}
}
------------------------------------------------------------
//引用传递；对象，本质还是值传递
public class Demo5 {
public static void main(String[] args) {
Person person = new Person();
System.out.println(person.name);//null
Demo5.change(person);//书源
System.out.println(person.name);
}
public static void change(Person person){
//person是一个对象：指向的是person person =new person（）；
//这是一个具体的人，可以改变属性！
person.name="书源";
}
}
//定义了一个Person类，有一个属性;name
class Person{
String name;//null
}
简单的分享过后在回忆一下下面的一些问题？
1、什么是面向过程
解决问题强调的是解决问题的基本步骤，强调的是解决方式，更强调方法。是一种编程思想：是一种自顶向下，不断分解 （ 准备盆、放水、放洗衣粉、放衣服、泡一泡、揉搓涮、晾干）
步骤清晰简单，第一步，第二步做什么 面对过程适合处理一些较为简单的问题
2、什么是面向对象
以类的方式组织代码，以对象的形式封装数据面向对象编程;
3、面向对象的好处是什么
物以类聚，分类的思维模式，先总结问题的分类，然后对分类进行单独思考，对某个细节进行面向过程思索面向对象适合处理复杂问题，适合处理需要多人协作的问题！
4、面向对象和面向过程的关系是什么
对于描述复杂的事务，从宏观上把握，从整体上合理分析，需要面向对象思路分析整个系统。但是，具体到微观操作仍需要面向过程去处理
6、成员变量和局部变量的区别
（1）成员变量是类变量，局部变量是方法变量他们都是用来存储数据的
（2）内存中所处的位置不同、初始化状态不同、生命周期不同（存活的时间不同）
7、如何定义类，类中有什么内容
修饰符 class 类名 ，类的属性，方法
8、如何定义对象，对象的使用方式
对象是一个具体的实例，定义对象需要一个类作为模版。使用new关键词创建对象通过 .（点）属性方法
9、类和对象的关系是什么
类是一个模版，对象是一个具体的实例
10、定义一个手机类，
属性：品牌brand、价格price
行为：可以查看手机信息look，作用输出手机的品牌和价格
11、定义一个动物类
属性：姓名name、年龄age
行为：吃、喝、睡
public class HomeWork1 {
public static void main(String[] args) {
// 10、定义一个手机类，
// 属性：品牌brand、价格price
// 行为：可以查看手机信息look，作用输出手机的品牌和价格
Phone p = new Phone();
p.brand = "华为";
p.price = 1111;
p.look();
Animal a = new Animal();
a.age = 3;
a.name = "小黑";
System.out.println(a.age);
System.out.println(a.name);
a.eat();
a.drink();
a.sleep();
}
}
class Phone{
String brand;
int price;
public void look(){
System.out.println("品牌" + brand + ",价格" + price);
}
}
//11、定义一个动物类
// 属性：姓名name、年龄age
// 行为：吃、喝、睡
class Animal{
String name;
int age;
public void eat(){
System.out.println("干饭");
}
public void drink(){
System.out.println("喝水");
}
public void sleep(){
System.out.println("睡觉");
}
}
篇幅最后在介绍一下匿名对象
3、匿名对象
格式：new 类名(); (没有名字的对象)
特点：只能使用一次
好处：在内存中存在的时间短，相对节省内存
使用场景，如果某个成员或者方法只使用一次，后面都不再使用了，此时就可以使用匿名对象
import java.util.Random;
public class Demo01 {
public static void main(String[] args) {
Person p = new Person(); //p中存储new Person()产生的地址值，p只是一个存储作用
//真正的对象产生是在new Person()
//匿名对象就是一个没有引用指向该对象的对象
//晚上随便找个人去跟陈毅睡觉
new Person().sleep("陈毅");
new Person().sleep("陈毅");
//匿名对象一般是使用行为(方法)
//一般不会通过匿名对象去给该对象的属性赋值
//使用对象都需要通过对象名 对象名中记录了地址
//此时赋值了，之后就找不到这个对象了，所以没有任何意义
new Person().name = "陈曦";
//使用场景
//如果对于某一个对象中的成员只需要使用一次，就可以使用匿名对象
int i = new Random().nextInt(2)+;
System.out.println(i);
//匿名对象使用一次之后，这个对象就不能在使用了，jvm虚拟机对于无法使用的对象就会把它当做垃圾
//此时就会被垃圾回收机制清理掉，占有的空间消失
//因此匿名对象在内存中存储的时间很短，相当于变相优化了内存的使用
}
}
class Person{
String name;
public void sleep(String str){
System.out.println("睡" + str);
}
}
后面的篇幅帮助大家继续理解Java的封装、多态和继承
8565
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
