Learning Java Day07

面向对象编程

Java的核心思想是OOP(面向对象编程)

OO -- 面向对象

属性+方法 -> 类

面向过程 & 面向对象

• 面向过程的思想 -- 线性

步骤清晰简单，第一步做什么，第二步做什么……

面向过程适合处理一些较为简单的问题

• 面向对象的思想

物以类聚，分类的思维模式，思考问题首先解决问题需要哪些分类，然后对这些分类进行单独思考，最后，才对某个分类下的细节进行面向过程的思索

面向对象适合处理复杂的问题，适合处理需要多人协作的问题

• 总结

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

什么是面向对象

• 面向对象编程(Object-Oriented Programming, OOP)

• 面向对象编程的本质 -- 以类的方式组织代码，以对象的组织(封装)数据

• 抽象

• 三大特性：

  • 封装

  • 继承

  • 多态

• 从认识论角度考虑问题是先有对象后有类，对象，是具体的事物；类，是抽象的，是对对象的抽象

• 从代码运行角度考虑是先有类后有对象，类是对象的模板

回顾方法的定义

 import java.io.IOException;
 ​
 //Demo 类
 public class Demo {
     //代码都写在main里面
     //main 方法
     public static void main(String[] args) {
         
     }
     /*
     修饰符 返回值类型 方法名 (...) {
         //方法体
         return 返回值;
     }
     方法名：注意规范，见名知意
     参数列表：(参数类型，参数名) ...
     异常抛出：疑问，后面讲解
      */
     public String sayHello () {
         return "hello, world!";
     }
     public void hello ()
     {
         //return;返回空值
     }
     public int max (int a, int b)
     {
         return a > b ? a : b; //三元运算符
     }
     /*
     break & return 的区别
     break -- 跳出switch, 结束循环
     return -- 结束方法，返回一个结果, 返回值与其类型对应, 可以为空
     return后不能再加语句, 否则IDEA会报错
      */
     
     //异常抛出
     //eg:数组下标越界 -- Arrayindexoutofbounds
     public void readFile (String file) throws IOException {
         
     }

回顾方法的调用

 public class Demo {
     public static void main(String[] args) {
         //静态方法 static
         Students.say();
 ​
         //非静态方法
         //Students.speak();报错
         //处理 -- 实例化这个类
         //对象类型 对象名 = 对象值
         Students students = new Students();
         students.speak();
     }
     //a、b同为静态或者非静态时可以互相调用
     public static void a () {
         b();
     }
     public static void b () {
 ​
     }
     /*
     public static void a () {
         b();
     }
     public void b () {
     }
     a为静态方法，b为非静态方法，如此调用不行
     即不可在静态中调用非静态
     原因分析：
     静态方法是和类一起加载的
     非静态方法是在类实例化之后才存在的
     如此调用存在时间差，即是调用一个不存在的东西报错
     */
 }
 //学生类
 public class Students {
 ​
     //非静态方法
     public void speak () {
         System.out.println("学生说话了");
     }
     //静态方法
     public static void say() {
         System.out.println("学生说话了！");
     }
 }
 ​

 public class Demo {
     public static void main(String[] args) {
         //实际参数和形式参数的类型要对应！
         int add = Demo.add(1, 2);
         System.out.println(add);
     }
     public static int add (int a, int b) {
         return a + b;
     }
 }

 public class Demo {
     public static void main(String[] args) {
         int a = 1;
         System.out.println(a); //1
         Demo.change(a);
         System.out.println(a); //1 -- 值传递 只将值传递进去
     }
     public static void change (int a)
     {
         a = 10;
     }
 }

 //引用传递：对象 -- 本质还是值传递
 //对象、内存！
 public class Demo {
     public static void main(String[] args) {
         Person person = new Person();
         System.out.println(person.name); // NULL
         Demo.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
 }

类与对象的关系

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

  • 动物、植物、手机、电脑……

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

• 对象是抽象概念的具体实例

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

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

创建和初始化对象

• 使用new关键字创建对象

• 使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用

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

  1. 必须和类的名字相同

  2. 必须没有返回类型，也不能写void

• 构造器必须要掌握

构造器总结：

1. 和类名相同

2. 没有返回值

作用：

1. new本质在调用构造器(方法)

2. 初始化对象的值

注意点：定义了有参构造之后，如果还想使用无参构造，显示地定义一个无参的构造

 //一个项目应该只存在一个main方法
 public class Application {
     public static void main(String[] args) {
         //类是抽象的 -> 实例化
         //类实例化后会返回一个自己的对象
         //students对象就是一个Students类的具体实例
         Students students = new Students();
 ​
         Students xiaoming = new Students();
         Students xiaohong = new Students();
         //默认初始化
         System.out.println(xiaoming.name); //null
         System.out.println(xiaoming.age);  //0
         //赋值
         xiaohong.name = "小红";
         xiaohong.age = 3;
         System.out.println(xiaohong.name); //小红
         System.out.println(xiaohong.age);  //3
     }
 }
 ​
 //学生类
 //好习惯 -- 不要在每个类中都加上main方法，在一个程序中只需要一个主启动类
 public class Students {
     //属性 -- 字段
     String name;
     int age;
 ​
     //方法
     public void study() {
         System.out.println(this.name + "在学习！");
     }
 }

 //一个项目应该只存在一个main方法
 public class Application {
     public static void main(String[] args) {
         //new实例化了一个对象
         Person person = new Person();
         System.out.println(person.name);// 卢威
     }
 }
 ​
 //java --> class
 public class Person {
     //一个类即使什么都不写，它也会存在一个方法 -- 构造方法
     //可打开对应的class文件查看
     //显示的定义构造器
     String name;
     //实例化初始值
     //1.使用new关键字，必须要有构造器，若是不写则会报错
     //因为使用new关键字，本质是在调用new构造器
     //2.用来初始化值
     /*
     不写IDEA会自动生成
     public Person() {
     }
      */
     //无参构造
     public Person() {
         this.name = "卢威";
     }
 }

 //一个项目应该只存在一个main方法
 public class Application {
     public static void main(String[] args) {
         //new实例化了一个对象
         Person person = new Person("卢威");
         System.out.println(person.name);// 卢威
     }
 }
 ​
 ​
 //java --> class
 public class Person {
 ​
     String name;
     //有参构造:一旦定义了有参构造，无参就必须显示定义
     public Person() {}
     
     public Person(String name) {
         this.name = name;
     }
 }

快捷键

ALT+INS(insert) -- 自动生成构造器

点击Constructor

可进行单选或者按住shift键多选来构造参数构造器

或者点击Select None来构造无参构造器

this

this.表示当前类的调用

 this.name = name; //对其赋值，一般为参数