JavaSE Day07

面向对象（1）

 

1. 什么是面向对象

面向对象的思想：物以类聚，分类的思维模式，然后对这些分类进行单独思考

属性+方法->类

对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们现需要面向对象的思路来分析整个系统。但是，具体到围观操作，仍然需要面向过程的思路去处理。

面向对象（Objiet-Oriented Programming，OOP）是框架，面向过程是流程。

面向对象编程的本质：以类的方式组织代码，以对象的组织（封装）数据

三大特性：封装、继承、多态

从认识论先有对象后又类。对象，是具体的食物；类，是抽象的事物，是对对象的抽象。

从代码运行角度是先有类后有对象。类是对象的模板

package com.oop;
 ​
 import java.io.IOException;
 ​
 //Demo01就是一个类
 public class Demo01 {
     //main 方法
     public static void main(String[] args) {
 ​
     }
 ​
     /*
     修饰符 返回值类型 方法名（。。。）{
         //方法体
         return 返回值；
     }
      */
     public String sayHello() {
         return "hello,world";
     }
 ​
     public int max(int a, int b) {
         return a > b ? a : b;
     }
 ​
     //throws IO抛出输出异常
     public void readFile(String file) throws IOException {
 ​
     }
 }

 

静态方法、非静态方法：

package com.oop;
 ​
 public class Demo02 {
     public static void main(String[] args) {
         //静态方法 static
         Student.say();
         //非静态方法,实例化这个类 new
         //对象类型 对象名=对象值
         Student student = new Student();
         student.say1();
 ​
     }
 ​
     //和类一起加载
     public static void a() {
         b();
     }
 ​
     //类实例化 之后才存在
     public void b() {
 ​
     }
 }

 package com.oop;
 ​
 //学生类
 public class Student {
 ​
     //静态方法
     public static void say() {
         System.out.println("学生说话");
     }
 ​
     public void say1() {
         System.out.println("学生说话");
     }
 ​
 }

 

值传递和引用传递：

 package com.oop;
 ​
 //引用传递：对象，本质还是值传递
 public class Demo03 {
     public static void main(String[] args) {
         Person person = new Person();
 ​
         System.out.println(person.name);//null
 ​
         Demo03.change(person);
 ​
         System.out.println(person.name);
     }
 ​
     public static void change(Person person) {
         //person是一个对象：指向的--->Person person = new Person();这是一个具体的人，可以改变属性
         person.name = "anzhenyu";
     }
 }
 ​
 class Person {
     String name;//null
 }

 

2. 类和对象的关系

1. 类是一种抽象的数据类型，它是对某一事物整体描述/定义，但是并不能代表某一个具体的事物。

　　　　动物、植物、手机、电脑

　　　　Person类、Pet类、Car类，这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为

2. 对象是抽象概念的具体实例

　　　　张三就是人的一个具体实例，张三家里的旺财狗就是一个实例

　　　　能够提现出特点，展现出功能的是具体的实例，而不是一个抽象的概念

 

3. 创建与初始化对象

使用new关键字创建对象

使用new后，除了分配内存外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。

 package com.oop.demo02;
 ​
 //学生类
 public class Student {
 ​
     //属性：字段
     String name;
     int age;
 ​
     //方法
     public void study() {
         System.out.println(this.name + "在学习");
     }
 }

 package com.oop.demo02;
 ​
 //一个项目应该只存在一个main方法
 public class Application {
     public static void main(String[] args) {
 ​
         //类：抽象的，需要实例化
         //类实例化后返回一个自己的对象！
         //student对象就是一个Student类的具体实例！！！
         Student student = new Student();
         Student xiaoming = new Student();
         Student xiaohong = new Student();
 ​
         xiaoming.name = "小明";
         xiaoming.age = 23;
 ​
         System.out.println(xiaoming.name);
         System.out.println(xiaoming.age);
         //调用方法
         xiaoming.study();
     }
 }

 

4. 构造器

类中的构造器也称为构造方法，是在进行创建对象的时候必须调用的。并且构造器有两个特点：

1.必须和类的名字相同。2.必须没有返回类型，也不能写void。

构造器必须掌握！

作用：

1. 使用new关键字，必须要有构造器（如果没有构造器，new一个对象会报错，本质就是调用构造器）

2. 用来初始化值

有参构造：一旦定义了有参构造，无参就必须显示定义

alt+insert自动生成构造器

 package com.oop.demo02;
 ​
 //java生成了一个class文件
 public class Person {
 ​
     //一个类即使什么都不写，他也会存在一个方法
 ​
     String name;
 ​
     //无参构造器
     //作用：实例化的初始值
     public Person() {
         this.name = "anzhenyu";
     }
 ​
     //有参构造:一旦定义了有参构造，无参就必须显示定义
     public Person(String name) {
         this.name = name;
     }
 ​
     //alt+insert
 ​
 }

package com.oop.demo02;
 ​
 //一个项目应该只存在一个main方法
 public class Application {
     public static void main(String[] args) {
 ​
         //new实例化了一个对象
         Person person = new Person();
         System.out.println(person.name);
     }
 }

 

5. 创建对象内存分析

 

6. 类与对象小结

1. 类与对象

　　　　类是一个模板：抽象；对象是一个具体的实例

2. 方法

　　　　定义、调用

3. 对应的引用

　　　　引用类型：基本类型

　　　　对象是通过引用来操作的：栈---->堆

4. 属性：字段 成员变量

　　　　默认初始化：

　　　　　　数字：0 0.0

　　　　　　char：u0000

　　　　　　boolean：false

　　　　　　引用：null

　　　　修饰符 属性类型 属性名=属性值！

5. 对象的创建与使用

　　　　---必须使用new关键字创建对象，构造器 Person yc = new Person（）

　　　　---对象的属性： yc.name

　　　　---对象的方法： yc.sleep()

6. 类：

　　　　静态的属性 属性

　　　　动态的行为 方法