java04 方法、面向对象、封装

1方法的概念

抽取提纯某一动作的即可为方法，若干语句的功能集合

public class Hello{
    public static void main(String[] args){
        //男人
        System.out.println("买房");
        //女人
        System.out.println("结婚");


    }
}

需要注意定义格式  参数和返回值

2如何定义它的格式

定义方法的完整格式：

修饰符  返回值类型  方法名称（参数类型 参数名称，参数类型 参数名称。。。。）{

     方法体

      return 返回值；//  参数如果有多个，用逗号分隔

}

格式 

         public  static void 方法名称（）{

                 方法体

          }

方法名称： 使用小驼峰 xiaoMiFeng

方法体：使用大括号当中可以包含任意条语句

程序入口：

public static void main（String[] args）{

     方法名称（）；

}

调用格式：方法名称（）；

注意事项：

1 方法定义的先后顺序，不重要；

2 方法定义不可以嵌套或包含的关系；不可嵌套定义。

3 方法定义OK，不会执行，如果想执行，一定要进行调用（执行方法）；也就是在main或其他地方进行调用中进行调用。

public class Hello{
    public static void main(String[] args){
        //男人 调用女人方法
        woMen(args);
        System.out.println("买房");
        //女人
    }
    public static void woMen(String[] args)    {
        System.out.println("结婚");


    }
}

结果

买房

结婚

3如何使用（调用）

方法其实就是若干语句的集合，好比是一个工厂。

参数 就是进入方法的数据

返回值 就是从方法中出来的数据，也就是产物

-----------------

定义方法的完整格式：

修饰符  返回值类型  方法名称（参数类型 参数名称，参数类型 参数名称。。。。）{

     方法体

      return 返回值；//  参数如果有多个，用逗号分隔

}

修饰符 现阶段的固定写法  public  static

返回值类型  也就是方法最终产生的数据结构是什么类型

方法名称 ： 方法的名字，规则和变量一样，小驼峰；

参数名称： 进入方法的数据对于的变量名称；

return ：两个作用

             1 停止当前方法

              2 将后面的返回值还给调用处；

举例 ： 定义一个两个int 类型数字相加的方法

三要素考虑  返回值类型 int  方法名称 sum  参数列表 int a  int b

2）调用方法的三种格式： 单独调用（结果无法使用） 打印调用  赋值调用（给变量）

1 单独调用： 方法名称（参数）；void 只能单独调用类型

public class HelloWorld2 {
    public static void main(String[] args){
        //单独调用
        int c = sum(10,20);

  // 打印调用
        System.out.println(c);
    }
    public static int sum(int a ,int b){
        int result1 = a + b;
        return result1;
    }
}
结果 30

2、打印调用：System.out.println();

public class HelloWorld2 {
    public static void main(String[] args){
        //单独调用
        int c = sum(10,20);  // 赋值调用

  // 打印调用
        System.out.println(c);
    }
    public static int sum(int a ,int b){
        int result1 = a + b;
        return result1;
    }
}
结果 30

3 赋值调用  数据类型  变量名称 = 方法名称（参数）；

public class HelloWorld2 {
    public static void main(String[] args){
        //单独调用
        int c = sum(10,20);

  // 打印调用
        System.out.println(c);
    }
    public static int sum(int a ,int b){
        int result1 = a + b;
        return result1;
    }
}
结果 30

3）整个程序执行过程

4） 对比参数方法 有参数和无参数

有参数： 当一个方法需要一些数据条件 ，才能完成任务的时候，就是有参数。

              例如方法是计算两个数据的和

下面是有参数：

public class HelloWorld2 {
    public static void main(String[] args){
        method1(10,20);
        //两个数字相乘，做乘法，得知道两个数据的值，否则无法计算

    }
    public static void method1(int a ,int b){
        //void 类型，可以使用打印println（结果）
        int result2 = a + b;
        System.out.println("结果是" + result2);
    }
}
结果30

无参数：小括号中留空，一个方法不需要任何数据条件，自己就能独立完成任 

              务，就是无参数。例如定义一个方法，打印固定10次的helloworld。

下面是无参数（你只需调用我这个方法，不需要传参数据，直接执行）

public class HelloWorld2 {
    public static void main(String[] args) {
        method2();
    }

    public static void method2() {
        for (int i = 0; i < 5; i++) {
            System.out.println("爱我中华");
        }
    }
}
结果
爱我中华
爱我中华
爱我中华
爱我中华
爱我中华

5）有无返回值案例：

原始题目 定义一个方法，用来计算两个数字的和（你帮我算，算完把结果给我）

有返回值的 可以单独调用  打印调用 或者赋值调用

无返回值的  也就是 void 只能单独调用。不可以打印调用或者赋值调用。

public class HelloWorld2 {
    public static void main(String[] args) {
        //我是main方法，我来调用你，你来帮我算一下，算完结果给我
        int num2 = getSum(10, 20);
        System.out.println(num2);
        }
    //我是一个方法，我负责两个数字相加
    //我有返回值int，谁调用我，我就把计算结果告诉谁。
    public static int getSum( int a,int b) {
        int sum1 = a + b;
        return sum1;
        }
}

结果30

变形题目 定义一个方法，用来打印两个数字的和（你帮我算，自己负责算完把结果打印）

public class HelloWorld2 {
    public static void main(String[] args) {
        //我是main方法，我来调用你，你来帮我算一下，算完结果给我
        int num2 = getSum(10, 20);
        System.out.println(num2);
        System.out.println("----------");
        getSum1(10,20);
        }
    //我是一个方法，我负责两个数字相加
    //我有返回值int，谁调用我，我就把计算结果告诉谁。
    public static int getSum( int a,int b) {
        int sum1 = a + b;
        return sum1;
        }
    //我是一个方法，我负责两个数字相加
    //我没有返回值，不会把计算结果告诉任何人。
    public static void getSum1( int a,int b) {
        int sum1 = a + b;
        System.out.println(sum1);
    }
}
结果
30
----------
30

整体效果如下：

定义一个方法，用来判断两个数字是否相同

//定义一个方法，用来判断两个数字是否相同
public class HelloWorld2 {
    public static void main(String[] args) {
        //方法的三要素  返回值类型 boolean    方法名称 isNum 参数列表 int a int b
        boolean issame2 = isSame(10,20);
        System.out.println(issame2);
    }
    public static boolean isSame(int a, int b){
        boolean same;
        if(a == b){
            same = true;

        }else {
            same = false;
        }
        return same;
    }
}
结果
false

定义一个方法，用来判断两个数字是否相同

//定义一个方法，用来判断两个数字是否相同
public class HelloWorld2 {
    public static void main(String[] args) {
        //方法的三要素  返回值类型 boolean    方法名称 isNum 参数列表 int a int b
        boolean issame2 = isSame(10,20);
        System.out.println(issame2);
    }
    public static boolean isSame(int a, int b){
        boolean same;
        if(a == b){
            same = true;

        }else {
            same = false;
        }
        return same;
    }
}

结果 false

定义一个方法，求出1-100之间的和

//定义一个方法，求出1-100之间的和
public class HelloWorld2 {
    public static void main(String[] args) {
        System.out.println(getSum1());
    }
        //返回值 int
        //参数列表 i++
        //方法名称getSum
    public static int getSum1 () {
        int sum1 = 0;
        for (int i = 1; i < 100; i++) {
            sum1 = sum1 + i;
        }
        return sum1;
        }
}
结果 4950

5 使用方法的注意事项

• 方法应该定义在类当中，不可以在方法中再定义一个方法。
• 方法定义的前后顺序无所谓
• 方法定义之后不会执行，如果希望执行，一定要调用；
• 如果方法有返回值，必须写上return 返回值；不能没有
• return 后面的返回值类型，必须和方法的返回值类型一一对应；
• 对于一个void没有返回值的方法，不能写return后面的返回值，只能return自己。也就是return；语句
• 对于方法中最后一行的return可以省略不写。
• 一个方法中，可以有多个return，但不可以同时执行2个，只能1个。

方法的重载

    假设一个方法 实现多个数字相加，可能两个 ，可能三个，可能四个，但是调用时候可能调用选择困难，对于功能类似的方法，那么如何减少调用选择而快速实现相加方法的执行，因此方法的重载，方便撰写方法，也方便调用。

定义：多个方法的名称一样，但参数列表不一样，而方法遵守小驼峰原则

方法的重载的关键点

• 1.参数个数不同，上图已演示；
• 2.参数个数相同但参数的类型不同，return可强壮类型
• 3.参数个数相同的多类型顺序不同
• 4.与方法的返回值类型无关

2.面向对象

    面向对象也就是面向谁开发，面向过程就是每个过程每个细节进行开发，而面向对象就是当实现某个功能的时候，找具备该功能的进行即可。

     面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了；面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。

     可以拿生活中的实例来理解面向过程与面向对象，例如五子棋，面向过程的设计思路就是首先分析问题的步骤：1、开始游戏，2、黑子先走，3、绘制画面，4、判断输赢，5、轮到白子，6、绘制画面，7、判断输赢，8、返回步骤2，9、输出最后结果。把上面每个步骤用不同的方法来实现。

       如果是面向对象的设计思想来解决问题。面向对象的设计则是从另外的思路来解决问题。整个五子棋可以分为1、黑白双方，这两方的行为是一模一样的，2、棋盘系统，负责绘制画面，3、规则系统，负责判定诸如犯规、输赢等。第一类对象（玩家对象）负责接受用户输入，并告知第二类对象（棋盘对象）棋子布局的变化，棋盘对象接收到了棋子的变化就要负责在屏幕上面显示出这种变化，同时利用第三类对象（规则系统）来对棋局进行判定。

      可以明显地看出，面向对象是以功能来划分问题，而不是步骤。两者之间的优缺点

• 面向过程：
• 优点：性能比面向对象高，因为面向对象时的类调用时需要实例化，开销较大，比较消耗资源;比如单片机、嵌入式开发、 Linux/Unix等一般采用面向过程开发，性能是最重要因素。
  缺点：没有面向对象易维护、易复用、易扩展
• 面向对象
• 优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统 更加灵活、更加易于维护
  缺点：性能比面向过程低

package cn.itcast.day04.demo01;
import java.util.Arrays;

public class HelloWorld {

    public static void main(String[] args) {
        int[] array = {10, 20, 30, 40, 50};
        System.out.print("[");//面向过程
        for (int i = 0; i < array.length; i++) {
            if (i == array.length - 1) {
                System.out.println(array[i] + "]");
            } else {
                System.out.print(array[i] + ",");
            }
        }
        System.out.println("==========");//分割线，找个Arrays类，tostring现成的方法
        System.out.println(Arrays.toString(array));//面向对象
    }
}

2.1.面向对象的特点与组成部分： 成员属性（也叫成员变量（是什么））与成员方法（能干啥）

 

成员变量（属性）

   数据名称 变量名称； int num = 10；

成员方法（行为）：成员方法特殊的地方就是没有static 即     public void eat（）；

  写在方法内部的叫局部变量

  写在类中间叫成员变量。

类定义： public class 类名（）{

                        成员变量；

                        成员方法；

} 其中public可写可不写；

package cn.itcast.day04.demo01;
public class HelloWorld {
    int name; //成员变量，写在类当中，而不是方法中
    public void eat(){
        int age;// 写在成员方法中的局部变量
        System.out.println("吃饭饭");
    }
// 成员方法没有static的，跟返回值和参数类型无关
    public void sleep() {
        System.out.println("睡觉");
    }
}

2.2.类的使用步骤：

1.导包，也就是导入正常需要使用的类，在什么位置；导包语句格式

import 包名称.类名称 假设导上面HelloWorld类

import cn.itcast.day04.demo01.HelloWorld;

2.创建格式

类名称 对象名 = new 类名称（）；

Student stu  =  new Student（）;

3.使用：成员变量和成员方法的使用方法

    对象名.成员变量 HelloWorld.name；

   对象名.成员方法（参数）HelloWorld.eat(参数)；

package cn.itcast.day04.demo01;
import cn.itcast.day04.demo01.HelloWorld;
public class Demo02 {
    public static void main(String[] args) {
        HelloWorld hw = new HelloWorld();
        hw.eat();
        hw.sleep();
    }
}

package cn.itcast.day04.demo01;
public class HelloWorld {
    int name; //成员变量，写在类当中，而不是方法中
    public void eat(){
        int age;// 写在成员方法中的局部变量
        System.out.println("吃饭饭");
    }
// 成员方法没有static的，跟返回值和参数类型无关
    public void sleep() {
        System.out.println("睡觉");
    }
}

如果成员变量未给值，则是默认值，规则和数组一样

int 为0；float为0.0，String是null，Boolean 为false，引用类型none

当我们创建一个对象，调用了成员方法和成员变量，那么内存中发生了什么变化。

      通常运行main方法之前，方法区有数据-方法区保存的是.class数据

栈 Stack，含义书架，也就是先进后出

• 每个线程包含一个栈区，栈中只保存基础数据类型的对象和自定义对象的引用(不是对象)，对象都存放在堆区中
• 每个栈中的数据(原始类型和对象引用)都是私有的，其他栈不能访问。
• 栈分为3个部分：基本类型变量区、执行环境上下文、操作指令区(存放操作指令)。

堆 Heap 许多 也就是先进先出

• 存储的全部是对象，每个对象都包含一个与之对应的class的信息。(class的目的是得到操作指令)
• jvm只有一个堆区(heap)被所有线程共享，堆中不存放基本类型和对象引用，只存放对象本身

方法区 Method Area

• 方法区又叫静态区，跟堆一样，被所有的线程共享。方法区包含所有的class和static变量。
• 方法区中包含的都是在整个程序中永远唯一的元素，如class，static变量。

02-两个对象使用同一个方法的内存图

03-两个引用指向同一个对象的内存图

      使用对象对方法进行参数传递。带static的方法是普通方法，不需要用对象点即可调用，直接使用。实际上传递的是地址值。

格式  public satatic void 方法名称（类名 对象名）{

                对象名.成员变量；

                对象名.成员方法；

            }

package cn.itcast.day04.demo01;
import cn.itcast.day04.demo01.HelloWorld;
public class Demo02 {
    public static void main(String[] args) {
        HelloWorld hw = new HelloWorld();
        System.out.println(hw.name);
        hw.eat();
        hw.sleep();
        hw.dd();
        Method(hw);
    }
    public static void Method(HelloWorld HH){
        System.out.println(HH.name);
    }
}

package cn.itcast.day04.demo01;
public class HelloWorld {
    Boolean  name; //成员变量，写在类当中，而不是方法中
    public void eat(){
        int age;// 写在成员方法中的局部变量
        System.out.println("吃饭饭");
    }
// 成员方法没有static的，跟返回值和参数类型无关
    public void sleep() {
        System.out.println("睡觉");
    }
    public static void dd(){
        System.out.println("跑步");
    }
}

       使用对象对方法进行参数传递。带static的方法是普通方法，不需要用对象点即可调用，直接使用。实际上传递的是地址值。

格式  public satatic 类名 方法名称（）{

               类名  对象名 = new 类名；

               方法体（对象名.成员变量  赋值）

               return 对象名； 此处返回地址值

         }

而接收方 需要进行赋值调用。

2.3局部变量和成员变量的区别

1.定义的位置不一样

局部变量：在方法内部

成员变量：在方法的外部；

2.作用范围不一样

局部变量：只有方法当中才可以使用，出了方法就不能再用

成员变量：整个类都已可以通用

3.默认值不一样

局部变量：没有默认值，如果要使用，需赋值，方法的参数也是局部变量。

成员变量：如果没有赋值，有默认值，和数组一样。

4.内存的位置不一样

局部变量 ：位于栈内存

成员变量：位于堆内存

5.生命周期不一样

局部变量：随着方法进栈而诞生，随着方法出栈而消失

成员变量：随着对象创建而诞生，随着对象被垃圾回收而消失

2.4.面向对象的三大特征、封装性、继承性、多态性。

封装性体现在：

1.方法就是一种封装

2.关键字private也是一种封装。

举例子：1.完成代码整合成方法，进行封装

举例子2 关键字private（私有化）的例子

private 私有化，main方法将无法调用，需要提供一对getAge和setAge方法

对于 setAge（int age）必须有参数（参数类型必须与成员变量对应），无返回值。

对于 getAge（）无参数，有返回值，返回值类型与成员变量对应。

快速生成setAge（）方法  alt + insert 选择set和get方法即可

特别注意：布尔值类型 是 setXXX和isXXX

       当方法的参数的局部变量和类的成员变量重名的时候，根据就近原则，方法的调用将优先使用方法传参的局部变量，如果是想用类的成员变量，可使用this.成员变量，从而进行区分。this关键字将是解决变量名重名的问题。调用谁的方法，this就是谁，this点的就是谁的成员变量而不是方法的局部变量（this也就是谁的地址）。

2.5 构造方法

为什么需要构造方法

• 面向对象的强制性要求

（1）构造方法是对象时用new关键字必须要调用的

（2）自己不定义任何构造方法时，编译器默认生成一个

• 初始化对象或其他任务

（1）完成对象属性初始化

（2）传递参数

（3）还可以完成信息的读取，或其他对象的初始化等任务

• 构造方法调用问题

（1）main方法进行构造方法的调用就是new的过程；

（2）类中构造方法直接调用使用this.变量名或者this（）代表构造方法

public class Person {
        private String name;
        private int age;
        //构造方法一
        public Person() {
            this(null);
        }
        //构造方法二
        public Person(String n) {
            this(n, 12);//调用第三个
        }
        //构造方法三
        public Person(String n, int a) {
            this.name = n;
            this.age = a;
        }
    }

        构造方法的名称必须和类名称一致，定义格式，构造方法的名称和类名称一样，首字符也得大写，构造方法没有返回值，连void都不写

public 类名称（）{方法体}

      构造方法的关键点：

1.如果没有写构造方法，将默认有无参构造方法；

2。构造方法也是可以进行重载的

package cn.itcast.day04.demo01.demo04;

public class Demo01 {
    public static void main(String[] args) {
        Person p = new Person();
        System.out.println("========");
        Person p2 = new Person("zhao",20);
        System.out.println(p2.name);
        System.out.println(p2.age);
        System.out.println("========");
        System.out.println(p2.getAge());
        System.out.println(p2.getName());
        p2.setAge(21);
        System.out.println(p2.getAge());
    }
}

package cn.itcast.day04.demo01.demo04;

public class Person {
    String name;
    int age;
    public Person(){
        System.out.println("无参构造方法执行");
    }
    public Person(String name , int num){
        this.name = name;
        this.age = num;
        System.out.println("全参数构造执行");
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

一旦需要改变参数中的内容，则需要使用set、get。因为一旦类成员变量进行private私有化，构造初始化是快捷、方便的。

由此 一个标准类（jave bean）的组成部分是：

1、所有的成员变量，进行私有化 private标注；

2. 所有的成员变量进行set/get方法

3.编写一个无参数的构造方法

4.编写一个有参数的构造方法；

或者说：

1、所有属性（成员变量）为private
2、提供默认构造方法
3、提供getter和setter
4、实现serializable接口（Java实体对象为什么一定要实现Serializable接口呢，因为实现Serilizable接口是为了序列化啊）