Learning Java Day07

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) {
         
     }
     
     public String sayHello () {
         return "hello, world!";
     }
     public void hello ()
     {
         //return;返回空值
     }
     public int max (int a, int b)
     {
         return a > b ? a : b; //三元运算符
     }
     
     
     //异常抛出
     //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 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关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用

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

必须和类的名字相同

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

构造器必须要掌握

构造器总结：

和类名相同

没有返回值

作用：

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

初始化对象的值

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

 //一个项目应该只存在一个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.用来初始化值
     
     //无参构造
     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; //对其赋值，一般为参数