面向对象编程

Java的核心思想就是OOP（面向对象编程）

面向过程&面向对象

面向过程思想 步骤清晰简单，第一步做什么，第二步做什么....

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

面向对象思想 抽象的概念 物以类聚，分类的思维模式，思考问题自尤云群大内壮加用去行单独思考。最后，才对某个分类下的细节进行面向过程的思索。 面向对象适合处理复杂的问题，适合处理需要多人协作的问题!

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

什么是面向对象

什么是面向对象 面向对象编程(Object-Oriented Programming, OOP)

面向对象编程的本质就是:以类的方式组织代码，以对象的组织(封装)数据。（读三遍！！！！！）

抽象

三大特性: 封装 继承 多态

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

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

回顾方法的定义

方法的定义 修饰符

返回类型

break：跳出switch,结束循环整个循环 和return的区别 return：方法结束，返回值类型相同/不带参数void （continue跳出一次循环）

方法名: 注意规范就OK 见名知意

参数列表：（参数类型，参数名）

异常抛出：后面讲解

方法的调用 静态方法

非静态方法

形参和实参

值传递和引用传递

this关键字

下边是练习：

 package com.oop.demo01;
 ​
 //Demo01 类
 public class Demo01 {
     //main方法
     public static void main(String[] args) {
 ​
     }
 ​
     /*
     修饰符  返回值类型 方法名（...）{
           //方法体
           return 返回值;
      */
     //定义一个方法，字符串
     //return 结束方法，返回一个结果
     public String theHello(){
         return "Hello World";
     }
 ​
     //三元运算符 max
     public static int max(int a,int b){
         return a>b ? a : b;
     }
 ​
     //抛出异常
     public void indexHello(String file) throws Exception{
     }
 }

 package com.oop.demo01;
 ​
 public class Demo02 {
     public static void main(String[] args) {
         //静态方法 static
         //Student.say();
         //非静态方法 实例化实现
         Student student = new Student();
         student.say();
     }
 ​
     //static和类一起加载的
     public static void a(){
         //b();
     }
     //类实例化 之后才存在
     public void b(){
 ​
     }
 }

 package com.oop.demo01;
 ​
 //形参和实参
 public class Demo03 {
     public static void main(String[] args) {
         /*Demo03 demo03 = new Demo03();
         //实际参数与形式参数的类型要对应
         int add = demo03.add(2, 3);
         System.out.println(add);*/
         //还有一种: 自己建的方法里加上修饰符 static直接调用add方法
     }
     public int add(int a,int b){
         return a+b;
     }
 }

 package com.oop.demo01;
 ​
 //值传递
 public class Demo04 {
     public static void main(String[] args) {
         int a = 1;
         System.out.println(a);//1
 ​
         chuanzhi(a);
         System.out.println(a);//1
 ​
     }
     public static void chuanzhi(int a){
         a = 10;//在里面a=10,出去后a还是1 因为返回值类型为void
     }
 }

 package com.oop.demo01;
 ​
 //引用传递: 对象  本质还是值传递
 public class Demo05 {
     public static void main(String[] args) {
 ​
         Person person = new Person();
         System.out.println(person.name);//null
 ​
         change(person);
         System.out.println(person.name);//为了她
 ​
         System.out.println(person.name+":"+person.sex+",年龄："+person.age+"岁");
 ​
     }
     public static void change(Person person){
         //perosn是一个对象:指向的--->Perosn perosn = new Perosn();这是一个具体的人，可以改变属性!
         person.name = "为了她";
         person.sex = "男";
         person.age = 22;
     }
 ​
 }
 //定义了一个Perosn类，有一个属性: name
 //在类下边  ： Demo05
 class Person{
     String name;//null
     String sex;
     int age;
 }

 package com.oop.demo01;
 ​
 public class Student {
     public static void main(String[] args) {
 ​
     }
     public void say(){
         System.out.println("学生说话了");
     }
 }