day06.方法 面向对象

课前回顾:
 1.内存:运行内存
   a.栈:
     方法的运行会进栈运行
   b.堆:
     引用数据类型的值,new的对象
   c.方法区:
     所有代码的"预备区"
   d.本地方法栈:
     运行带native的方法
   e.寄存器:
     和CPU有关系
 2.二维数组:
   a.定义:
     数据类型[][] 数组名 = new 数据类型[m][n]
     数据类型[][] 数组名 = {{元素1,元素2...},{元素1,元素2...}...}
   b.存元素:
     数组名[i][j] = 值
   c.取元素:
     数组名[i][j]
   d.遍历:嵌套循环

 3.方法:拥有功能性代码的代码块,将来一个功能就应该定义一个方法
   a.通用定义格式:
     修饰符 返回值类型 方法名(参数){
         方法体
         return 结果
     }

   b.无参无返回值方法:
     public static void 方法名(){
         方法体
     }

     直接调用:方法名()

   c.有参无返回值方法:
     public static void 方法名(形参){
         方法体
     }

     直接调用:方法名(实参)

   d.无参有返回值方法:
     public static 返回值类型 方法名(){
         方法体
         return 结果
     }

     赋值调用: 数据类型 变量名 = 方法名()

   e.有参有返回值方法:
     public static 返回值类型 方法名(形参){
         方法体
         return 结果
     }

     赋值调用:数据类型 变量名 = 方法名(实参)

   f.参数和返回值的使用时机:
     参数:想将一个方法中的数据传递到另外一个方法中,用参数传递
     返回值:调用方法之后需要用到这个方法的结果,此方法需要将自己的结果返回

   g.形参和实参:
     形参:在定义方法的时候形式上定义的参数,此时参数是么有值的
     实参:在调用方法的时候给形参传递的具体的值

   h.方法注意事项
     方法不调用不执行
     方法之间不能互相嵌套
     方法的执行顺序只和调用顺序有关
     void不能和return 结果共存,但是能和return共存
     main是jvm自动调用
     调用方法的时候要完全匹配
     一个方法不能连续写多个return


今天重点:
  1.能分清什么方法是重载方法
  2.知道什么是面向对象思想
  3.知道为啥要使用面向对象编程
  4.知道什么时候使用面向对象思想编程
  5.怎么使用面向对象思想编程
  6.会用代码去描述世间万物的分类
  7.会利用new对象的形式去调用别的类中的方法

第一章.方法练习

1.方法练习 1(判断奇偶性)

需求:
   键盘录入一个整数,将整数传递到另外一个方法中,在此方法中判断这个整数的奇偶性
   如果是偶数,方法返回"偶数"  否则返回"奇数"

参数:要
方法名:要
返回值:要

public class Demo01Method {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int data = sc.nextInt();
        String result = method(data);
        System.out.println("result = " + result);
    }

    public static String method(int data){
        if (data%2==0){
            return "偶数";
        }else{
            return "奇数";
        }
    }
}

2.方法练习 2(1-100 的和)

需求 :  求出1-100的和,并将结果返回
参数:不要
返回值:要
方法名:要

public class Demo02Method {
    public static void main(String[] args) {
        int result = method();
        System.out.println("result = " + result);
    }

    public static int method(){
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            sum+=i;
        }
        return sum;
    }
}

3.方法练习 3(不定次数打印)

需求:
   定义一个方法,给这个方法传几,就让这个方法循环打印几次"我是一个有经验的JAVA开发工程师"
参数:要
返回值:不要
方法名:要

public class Demo03Method {
    public static void main(String[] args) {
        method(5);
    }
    public static void method(int n){
        for (int i = 0; i < n; i++) {
            System.out.println("我爱money");
        }
    }
}

4.方法练习 4(遍历数组)

需求:
  在main方法中定义一个数组,将数组传递到方法中,在此方法中遍历数组

参数传递的是数组,属于引用类型,所以我们传递的是地址值

5.方法练习 5(求数组最大值)

需求:
  在main方法中定义数组,传递到另外一个方法中,在此方法中实现获取数组最大值

自己做

6.方法练习 6(按照指定格式输出数组元素)

需求:
  1.定义一个数组 int[] arr = {1,2,3,4}
  2.遍历数组,输出元素按照[1,2,3,4]

自己做

7.练习 7

数组作为返回值返回

public class Demo05Method {
    public static void main(String[] args) {
        int[] arr2 = method();
        for (int i = 0; i < arr2.length; i++) {
            System.out.println(arr2[i]);
        }
    }

    public static int[] method() {
        int a = 10;
        int b = 20;
        int sum = a + b;
        int sub = a - b;

        int[] arr1 = {sum, sub};
        //返回的是int型数组
        return arr1;
    }
}

返回值是一个数组,数组属于引用类型,返回的是地址值

第二章.方法的重载(Overload)

1.需求:定义三个方法,分别求两个数的和,三个数的和,四个数的和

public class Demo06OverLoad {
    public static void main(String[] args) {
         sum(10,20);
         sum(10,20,30);
    }

    public static void sum(int a,int b){
        int sum = a+b;
        System.out.println("sum = " + sum);
    }

    public static void sum(int a,int b,int c){
        int sum = a+b+c;
        System.out.println("sum = " + sum);
    }

    public static void sum(int a,int b,int c,int d){
        int sum = a+b+c+d;
        System.out.println("sum = " + sum);
    }
}

按住 ctrl 不放,鼠标点击,变量名,方法名,对象名等,会跳到对应的位置 -> 可以快速知道我们使用的成员在什么位置上

1.概述:方法名相同,参数列表不同的方法->重载方法

2.什么叫做参数列表不同:
  a.参数个数不同
  b.参数类型不同
  c.参数类型顺序不同

3.和什么无关:
  a.和返回值无关
  b.和参数名无关

public class Demo07OverLoad {
    public static void main(String[] args) {
        method(10,20);
    }

    public static void method(){

    }

    public static void method(int a,int b){

    }
    /*public static void method(int x,int y){

    }*/

/*    public static int method(int x,int y){
        return 0;
    }*/

    public static void method(int a,double b){

    }

    public static void method(double a,int b){

    }
}

public static void open(){}
public static void open(int a){}
static void open(int a,int b){}
public static void open(double a,int b){}
public static void open(int a,double b){}
public void open(int i,double d){}
public static void OPEN(){}
public static void open(int i,int j){}

1.使用场景:
  功能一样,实现细节不一样,就可以定义重载的方法

第三章.类和对象

面向对象思想:  java的核心编程思想

1.面向对象的介绍

1.什么是面向对象思想:java的核心编程思想
2.为什么要使用面向对象思想编程:
  有很多功能别人都写好了我们直接创建这个对象,直接拿过来用我们的功能就能实现 -> 懒
   -> 为了少写代码
3.什么时候要使用面向对象思想编程:
  在一个类中想使用别的类实现好的功能时,就需要使用面向对象思想编程了
4.怎么使用面向对象思想编程:
  a.new呀,点呀
  b.特殊:调用带static关键字的 -> 直接类名点

public class Demo01Object {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4};
       /* System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (i== arr.length-1){
                System.out.print(arr[i]+"]");
            }else{
                System.out.print(arr[i]+",");
            }
        }*/

        System.out.println(Arrays.toString(arr));

        System.out.println("======================");
        Random rd = new Random();
        int i = rd.nextInt(100);
        System.out.println("i = " + i);
    }
}

2.类和对象

2.1 类(实体类)_class

1.类分为两种:
  a.实体类 -> 世间万物的分类
  b.测试类 -> 带main方法的类 -> 为了测试代码是否能跑通的类

1.类的概述:
  一类事物的抽象表示形式
2.实体类包含两部分:
  属性(这个分类有啥)-> 成员变量
    a.定义格式:  数据类型 变量名
    b.定义位置:  类中方法外
    c.成员变量有默认值:
      整数 0
      小数 0.0
      字符 '\u0000'
      布尔  false
      引用  null

  行为(这个分类能干啥,有什么功能) -> 成员方法
      将之前的方法干掉static关键字,其他的一样

public class Person {
    //属性 -> 成员变量
    String name;
    int age;

    //行为 -> 成员方法
    public void eat(){
        System.out.println("人要吃饭");
    }

    public void drink(){
        System.out.println("人要喝水");
    }

    public void la(){
        System.out.println("人要出恭");
    }

    public void sa(){
        System.out.println("人要嘘嘘");
    }
}

描述动物类

public class Animal {
    String brank;
    String age;
    String color;

    public void sleep(){
        System.out.println("动物要睡觉");
    }

    public void jiao(){
        System.out.println("动物会都嚎叫");
    }
}

描述手机类

public class Phone {
    String brand;
    double price;
    String color;

    public void call(String name){
        System.out.println("给"+name+"打电话");
    }

    public String sendMessage(){
        return "半夜给金莲发短信";
    }
}

2.2.对象

1.概述:
  一类事物的具体体现
2.使用:
  a.导包:import 包名.类名
    如果两个类不在同一个包下,使用对方的成员就需要导包
    如果两个类在同一个包下,使用对方的成员就不需要导包

  b.创建对象:想要调用哪个类的成员,就new哪个类的对象
    类名 对象名 = new 类名()

  c.调用成员(成员方法,成员变量)
    对象名.成员变量名 = 值
    对象名.方法名()

public class Person {
    //属性 -> 成员变量
    String name;
    int age;

    //行为 -> 成员方法
    public void eat(){
        System.out.println("人要吃饭");
    }

    public void drink(){
        System.out.println("人要喝水");
    }

    public void la(){
        System.out.println("人要出恭");
    }

    public void sa(){
        System.out.println("人要嘘嘘");
    }
}

public class Demo02Object {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);
        System.out.println(person.age);

        person.name = "涛哥";
        person.age = 18;
        System.out.println(person.name);
        System.out.println(person.age);

        person.eat();
        person.drink();
        person.la();
        person.sa();
    }
}

public class Phone {
    String brand;
    double price;
    String color;

    public void call(String name){
        System.out.println("给"+name+"打电话");
    }

    public String sendMessage(){
        return "半夜给金莲发短信";
    }
}

public class Demo03Object {
    public static void main(String[] args) {
        Phone phone = new Phone();
        phone.brand = "华为";
        phone.price = 8999;
        phone.color = "黑色";
        System.out.println(phone.brand);
        System.out.println(phone.price);
        System.out.println(phone.color);

        phone.call("柳岩");
        String mess = phone.sendMessage();
        System.out.println(mess);
    }
}

2.3.练习

需求:用代码去描述一个动物类,在测试类中为动物类中的属性赋值,并且调用动物类中的功能

自己做

3.匿名对象的使用

1.int i = 10
  int:数据类型
  i:变量名
  10:具体的值

2.Person p = new Person()
  Person:数据类型
  p:变量名
  new Person():具体的值->是一个Person对象

1.匿名对象:new对象的时候,没有等号左边,只有等号右边的new对象部分
  有名对象:Person p = new Person()
  匿名对象:new Person()

2.使用:
  new Person().成员名

3.优缺点:
  a.优点:好使用
  b.缺点大大的:对象不能循环使用,浪费内存

4.注意:
  a.如果我们想临时的调用一次方法,我们可以使用匿名对象
  b.但是如果涉及到赋值,千万不要使用

public class Demo04Object {
    public static void main(String[] args) {
        //有名对象
        Person p = new Person();
        p.eat();
        p.drink();

        System.out.println("=================");

        //匿名对象
        new Person().eat();
        new Person().drink();
    }
}

public class Demo05Object {
    public static void main(String[] args) {
        //有名对象
        Person p = new Person();
        p.name="小明";
        System.out.println(p.name);
        System.out.println("=================");

        //匿名对象
        new Person().name="小红";
        System.out.println(new Person().name);
    }
}

4.一个对象的内存图

public class Phone {
    String brand;
    int price;

    public void call(){
        System.out.println("打电话");
    }
}

public class Demo01Object {
    public static void main(String[] args) {
        Phone phone1 = new Phone();
        System.out.println(phone1);//地址值
        System.out.println(phone1.brand);//默认值
        System.out.println(phone1.price);//默认值
        phone1.brand = "华为";
        phone1.price = 8999;
        System.out.println(phone1.brand);//华为
        System.out.println(phone1.price);//8999
        phone1.call();
    }
}

5.两个对象的内存图

new 了两次,开辟了两个不同的空间,修改一个空间中的数据,不会影响到另外一个空间的数据

6.两个对象指向同一片空间内存图

phone2 是 phone1 直接赋值的,所以会将 phone1 的地址值给 phone2,此时 phone1 和 phone2 地址值是一样的,操作的是同一片空间,所以操作一个对象的数据会影响另外一个对象的数据

第四章.成员变量和局部变量区别

1.定义位置不同:
  a.成员变量:类中方法外
  b.局部变量:方法内部,或者参数位置上
2.初始化值不同:
  a.成员变量:是有默认值的,不需要赋值就能直接使用
  b.局部变量:没有默认值的,必须先初始化才能使用
3.作用范围不同:
  a.成员变量:作用于整个类
  b.局部变量:只作用于自己所在的方法内部
4.内存位置不同:
  a.成员变量:在堆中,因为成员变量跟着对象走
  b.局部变量:在栈中,因为局部变量跟着方法走
5.生命周期不同:
  a.成员变量:随着对象的创建而创建,随着对象的消失而消失
  b.局部变量:随着方法的执行而创建,随着方法的弹栈而消失

public class Person {
    String name;//成员变量

    public void eat(){
        //局部变量
        int i = 10;
        System.out.println(i);

        int j;
        //System.out.println("j = " + j);

        System.out.println(name);
    }

    public void drink(){
        System.out.println(name);
        //System.out.println(i);
    }
}

第五章.练习

1.定义一个类MyDate,代表生日,类中定义三个属性,分别为 year  month  day,并为三个属性赋值

public class MyDate {
    int year;
    int month;
    int day;
}

public class Test01 {
    public static void main(String[] args) {
        MyDate myDate = new MyDate();
        myDate.year = 2008;
        myDate.month = 1;
        myDate.day = 1;

        System.out.println(myDate.year);
        System.out.println(myDate.month);
        System.out.println(myDate.day);
    }
}

2.定义一个公民类Citizen,类中定义三个属性,分别为cardId(String),name(String),MyDate(MyDate),并为三个属性赋值

  注意:如果属性为自定义的类型,赋值是需要new对象赋值,不然直接调用时会出现空指针异常

public class Citizen {
    String cardId;//身份证  null
    String name;//姓名   null

    /*
       自定义类型赋值,应该通过new对象赋值
     */
    MyDate myDate; //null
}

public class Test02 {
    public static void main(String[] args) {
        Citizen citizen = new Citizen();
        citizen.cardId = "1111111";
        citizen.name = "涛哥";
        MyDate birthday = citizen.myDate;
        birthday = new MyDate();
        birthday.year = 2008;
        birthday.month = 1;
        birthday.day = 1;

        System.out.println(citizen.cardId);
        System.out.println(citizen.name);
        System.out.println(birthday.year);
        System.out.println(birthday.month);
        System.out.println(birthday.day);

    }
}