对象类，属性，构造方法

一.Java面向对象

面向对象(Object Oriented)是软件开发方法。面向对象的概念和应用已超越了程序设计和软件开发，扩展到如数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。面向对象是一种对现实世界理解和抽象的方法，是计算机编程技术发展到一定阶段后的产物。

面向对象是相对于面向过程来讲的，面向对象方法，把相关的数据和方法组织为一个整体来看待，从更高的层次来进行系统建模，更贴近事物的自然运行模式。

java中最小单位是类,用class表示，不是java文件
Java中的面向对象就是使用对象来进行事物的操作
对象是由类得到的 所以要现有类 才有对象

类是具有相同属性和方法的多个对象的抽象
对象是类的一个具体的实例
属性是静态描述 直观的不可变 姓名 肤色 性别
方法—行为是动态部分 可以干什么 学习 打游戏 吃饭 逛街

二. 面向对象的具体操作 ：类和对象的介绍

在java中用类来表示现实事物，用对象来实际操作代码。对象是通过类来得到的（new只是一种方式） ,创建一个现实事物到java中， 想创建学生就到java中就去创建一个Student类（名字叫Student 使用class关键字来描述 ）

1.属性部分 静态部分

所谓的属性其实就是我们之前学习过的变量
只要是用来创建对象的类 bean entity
Com.xingyun.bean
Com.xingyun.entity
a.全局属性 全局变量
直接声明在类中的变量 ，全局变量拥有默认值

public class StudentText {
 public static void main(String[] args) {
  //实例化一个对象
  //默认会调用无参数构造方法
  Student stu01=new Student();
  //使用默认值和初始值
  System.out.println("姓名"+stu01.name);
  System.out.println("年龄"+stu01.age);
  System.out.println(stu01.courses);
  //给对象赋予自己的初始值
  stu01.name="huang";
  stu01.age=18;
  String  []courses=new String[] {"数学","语文"};
  System.out.println("姓名"+stu01.name);
  System.out.println("年龄"+stu01.age);   
  System.out.println(stu01.courses);
  String [] couse=stu01.courses;//获取学生的学科信息
  System.out.println(stu01.courses);//直接输出，对象的数组类型属性
  //遍历输出
  for (String i : courses) {
   System.out.println(i);
   
  }

b.局部属性 局部变量
声明在方法中的变量，没有默认值，要想使用就必须先赋值在使用
局部变量只在局部有效{所在}，局部变量可以与全局变量同名，局部优先原则（就近原则）

public void math() {
//声明局部变量
  int sum=0;
  for (int i = 0; i <= 10; i++) {
   sum+=i;
  }
  System.out.println("1到10的总和为"+sum);
 }

2.方法部分 行为 动态部分

（1） 构造方法 使用来实例化对象用的

a. 无参数构造方法 实例化 但是不赋值

语法：  public  类名（）{    }     

//无参构造方法
 public Car() {
   System.out.println("无参构造方法被调用");
 }
 

// 创建构造方法
public Student() {
       System.out.println("student的无参数构造方法");
       }
//实例化student对象    默认调用无参数构造方法
Student  stu = new Student(); //无参数构造方法消失了

实例化student对象 默认调用无参数构造方法
每一个类在创建之后都有一个默认的无参数构造方法，如果该类中有参数构造方法，那么默认的无参数构造方法就不存在了 。
在类中 尽量将无参数构造方法显示的写出来(JavaBean)
b. 有参数构造方法 实例化对象并给属性赋值

    语法：  public  类名（...）{    }

public class Student {
  int stuId;//设置编号
 int age;//设置年龄
 String name;//姓名
 String[] courses;//由于课程是多个，使用数组
  //所有参数构造方法(四个参数)
 public Student(int stuId,String name,int age,String[] courses) {
  //赋值
  this.stuId=stuId;
  this.name=name;
  this.age=age;
  this.courses=courses;
  System.out.println("所有属性赋值，构造方法");
 }
 /无参构造方法
 public Student() {
  System.out.println("Student的无参构造方法");
 }
数在构造方法中等同于局部变量
 //一个参数的构造方法
 public Student(String mingzi) {
  System.out.println("形式参数的值是"+mingzi);
  System.out.println("一个参数的构造方法 参数类型是String");
  //在构造方法中，形式参数的值就是用来给对象的属性赋值用的
  name=mingzi;
 }
 public Student(int sid) {
  System.out.println("形式参数的值是"+sid);
  System.out.println("一个参数的构造方法 参数类型是int"); 
  stuId=sid; 
 }
  //两个参数
 public Student(String xingming,int nianling){
  System.out.println("第一个两个参数的");
 }
 public Student(int nianling,String xingming){
  System.out.println("第二个两个参数的");
 }

声明方法的时候（）中的参数叫做形式参数，在调用方法的时候的值为实际参数。实际参数会将值赋值给形式参数

有参数构造方法 可以给所有的属性赋值 也可以给部分属性赋值

在实例化student对象的时候，根据实际参数的类型以及个数以及类型顺序来选择对应的构造方法实例化对象
形式 参数 的名字可以是任意的，为了给属性赋值方便一般使用与属性一样的名字。

（2）普通方法 对象的行为

语法：

[访问限定符]  [修饰符] 
返回值类型  方法名字（[参数]）{方法体}

[]标记的为可有可无
访问限定符 ：public、protected、无（default）、private
修饰符 ：static final
返回值类型 ： 无返回值void 有返回值（任意类型）
[参数] ：形式参数 实际参数 数据类型 … 名字(多个参数)
作用 ： 就是对象要实际做的操作（过程代码），方法可以作为参数 进行使用
方法的分类 ：
返回值 ：使用该方法之后 会得到返回一个结果（一个具体的数据） 使用关键字return
参数的作用 ： 该参数为形式参数 需要在方法被调用的时候传入实际参数
全部采用public 关键字修饰 无修饰符
a.没有参数没有返回值

//普通方法
 public void run() {
  System.out.println("汽车可以跑了");
 }
 //1--10总和      无参数无返回值
 public void math() {
  int sum=0;
  for (int i = 0; i <= 10; i++) {
   sum+=i;
  }
  System.out.println("1到10的总和为"+sum);
 }

b.有参数没有返回值

    // 没有参数有返回值   参数的个数可以有多个
 public void math1(int endsum) {
  int sum=0;
  for (int i = 0; i <= endsum; i++) {
   sum+=i;
  }
  System.out.println("1-----"+endsum+"的总和为"+sum);
 }

方法的参数可以是任意类型的， 基本 、数组 、对象
参数是基本类型

// 参数的个数是两个基本数据类型的
 public void math2(int num1,int num2) {
  System.out.println("num1和num2的和为"+(num1+num2));
  System.out.println("num1和num2的差为"+(num1-num2));
  System.out.println("num1和num2的乘为"+(num1*num2));
  System.out.println("num1和num2的除为"+(num1/num2));
 }

参数是数组类型 引用数据类型

//数组类型的参数 (function)
 public void arrFun(String[] arr) {
  System.out.println(arr);//输出的是数组的地址值
  for (String name : arr) {
   System.out.println("遍历数组"+name);//遍历数组
  }
 }

参数是对象类型

//  参数是对象   类类型的形式参数   类类型的变量
public  void show(Student stu) {
//不能获取null对象中的数据  属性和方法 
            System.out.println(stu.name);
            }

c.没有参数有返回值
在使用方法之后 会得到一个返回结果 必须使用return关键返回数据.
return关键字的使用： 在一个方法中可以有多个return关键字 ，但是该方法的最后一行执行代码必须是return。 方法规定返回值类型是什么 return就必须返回对应的数据类型。

语法：

 public   数据类型   方法的名（）{    return 数据}

返回基本数据类 8个+String

返回数组类型

返回对象类型

//有返回值的方法
//返回值是基本数据类型
 public double avg() {
  double math=99;
  double english=88;
  double avg=(math+english)/2;
  return avg;
    
 }
 //放回值是数组类型，可以有多个return关键字
//最后一句代码必须是return语句(不懂)
 public int[] array() {
  int num=2;
  if(num==1) {
   return new int[] {10,20,30};
  }else {
   return new int[] {100,200};
  }
 }
 
 //返回值是自定义类型
 public Student getStudent() {
  Student student=new Student();
  return student;
 }

d.有参数有返回值
形参用实际参数赋值，根据参数在方法内部进行操作得到需要的返回值
根据参数得到对应的student对象

//有参数有返回值
 public Student getObj(String name) {
  Student stu = new Student();
  stu.name = name;// 赋值
  System.out.println(stu.name);
  return stu;// 返回
 }

（3）代码块
普通代码块 使用{ }
在实例化对象的时候执行，实例化一回执行一回

//普通代码块
 {
  System.out.println("普通代码块执行成功");
 }

静态代码块 就是在代码块前使用static关键字

//静态代码块
 static {
  System.out.println("静态代码块执行成功");
 }

在类被加载的时候执行但是只执行一次，在实例化对象的时候执行，第一次实例化的时候执行。 同一次操作 在程序启动时进行数据的初始化操作
（4）对象
使用类类型的变量（引用类型变量）名字 接收 new类得到对象
语法 ：

Student  stu01=new  Student(); 

new 的东西都会保存到堆内存中，用来引用实例化的对象的变量都保存到栈内存中
对象方法的调用：此处采用junit单元测试的方式进行方法的调用

3.面向对象的方法的详细介绍

1. 方法的参数传递
实参给形参传递的都是值传递: 数据值 地址值
A.参数是基本数据类型 值传递 传递的是具体的一个数值
值传递 形式参数的改变不会影响 实参的值

// 值传递
 public void setNum(int num) {
 // 修改形式参数的值
 num = 100;
 System.out.println("方法中的num变量的值是" + num);
 }
 @Test
 void test() {
  Student stu=new Student();
  int num=10;
  System.out.println("传递之前num的值"+num);
  stu.setNum(num);
  System.out.println("传递之后num的值"+num);
 }

B.参数是引用（数组、对象）类型 值传递 传递的地址值 引用

参数的类型是引用数据类型，在实参给形式参数赋值时，其实是将实际参数的堆内存中的数据的引用地址 赋值给形式参数。 形式参数与实际参数所指向的堆内存空间就为同一个。 形式参数修改数据 就会引起堆内存数据的改变， 实际参数的值也就会随之发生改变

// 引用传递 地址传递
 public void setObj(Student student) {
  System.out.println("方法中的student的age修改前的值是" + student.age);
  // 修改student的age值
  student.age = 100;
  System.out.println("方法中的student的age值是" + student.age);
 }
 @Test
 void test01() {
  //传递的实参对象   age值是20
  Student stu01=new Student();
  stu01.age=20;
  System.out.println("传递之前age的值"+stu01.age);
  Student student = new Student();
  student.setObj(stu01);//调用方法
  System.out.println("传递之后age的值"+stu01.age);
 }
  public void setArray(int [] nums) {
    
    nums[0]=100;
     
 }
 @Test
 void test02() {
    Student stu = new Student();
    int [] nums=new int[] {10,20,30};
    System.out.println("传递前"+nums[0]);
    stu.setArray(nums);
    System.out.println("传递后"+nums[0]);
 }

2.方法的使用

(1) 方法调方法 （在同一个类中）

在没有使用 static关键字来修饰方法时，如果有static关键字修饰
静态方法只能调用静态方法，非静态方法可以调用静态和非静态方法

public class People {
 public void eat(String name) {
  //调用getMoney
  getMoney();
  System.out.println(name+"在约会");
 }
 public void getMoney() {
  System.out.println("我想要赚钱了");
  
 }
 public static void play() {
  //eat();不能直接调用，非静态方法
  System.out.println("你怎么又在玩了");
 }
 public static void drink() {
  
  System.out.println("我想要喝水了");
 }
 public void countMoney(double money) {
  System.out.println("我今天挣了"+money+"元");
 }

（2）方法自己调自己
称为递归： 方法自己调用自己
避免无限调用 发生栈内存溢出错误

//使用递归进行1-----10的阶乘
 public int sum(int num) {//num 阶乘的最大数字
 //当边界条件不满足时，递归前进；当边界条件满足时，递归返回。
   if(num==10) {
    return 10; 
   }else {
    return num+sum(num+1);
  }}

（3） 方法当做参数使用

主要指的是有返回值的方法
将方法的返回值当做实际参数进行调用

在同一个类中 ，有多个方法 。
方法的名字一致 ，参数的类型，个数 ，类型顺序不同就构成方法的重载。跟返回值没有关系

4.对象的引用 类与类的引用
类的属性是其他的类类型