方法的重载_面向对象

  1. 课前回顾:
  2.   1.二维数组
  3.     动态初始化:
  4.      数据类型[][] 数组名 = new 数据类型[二维数组长度][每一个一维数组长度]
  5.     静态初始化:
  6.      数据类型[][] 数组名 = {{},{},{}}
  7.     存储元素:
  8.      数组名[i][j] = 元素值
  9.      i:代表的是一维数组在二维数组中的索引位置
  10.      j:代表的是元素在一维数组中的索引位置
  11.     获取元素:
  12.      数组名[i][j]
  13.     遍历:先遍历二维数组,再遍历一维数组
  14.     获取二维数组长度:数组名.length
  15.   2.方法
  16.     a.概述:功能
  17.     b.作用:好维护,提高了复用性
  18.     c.
  19.       无参无返回值
  20.         public static void 方法名(){
  21.           方法体
  22.         }
  23.         方法名()
  24.       有参无返回值
  25.         public static void 方法名(参数){
  26.           方法体
  27.         }
  28.         方法名(具体的值)
  29.       无参有返回值
  30.         public static 数据类型 方法名(){
  31.           方法体
  32.           return 结果
  33.         }
  34.         数据类型 变量名 = 方法名()
  35.       有参有返回值
  36.          public static 数据类型 方法名(参数){
  37.           方法体
  38.           return 结果
  39.         }
  40.         数据类型 变量名 = 方法名(具体的值)
  41.   3.注意事项:
  42.     a.方法不调用不执行  main方法是jvm调用的
  43.     b.方法之间不能嵌套的
  44.     c.方法的执行顺序只和调用顺序有关
  45.     d.void 和 return 结果 不能共存的
  46.       void 能和return 共存
  47.     e.一个方法中,不能连续return多个返回值(if else 除外)
  48.     f.调用方法时,要和下面定义好的方法完全匹配
  50. 今日重点:
  51.    1.会使用debug调试代码
  52.    2.什么是面向对象思想
  53.    3.为什么要是会用面向对象思想
  54.    4.怎么使用面向对象
  55.    5.会用代码描述我们世间万物的类
  56.    6.会在一个类中使用别的类中的成员->面向对象
  57.    7.会new对象,点别的类的成员
  58.    8.知道成员变量和局部变量的区别
  59.    9.会定义静态成员,以及会调用静态成员(类名直接点)

第一章.debug

  1. 1.概述:代码调试手段(工具)
  2. 2.作用:
  3.   a.可以让代码一行一行的执行
  4.   b.能够清楚的看到代码中每一个成员值的变化
  5.   c.找bug
  6. 3.怎么使用:
  7.   a.在想开始执行的那一行左边单击一下,点出一个红色大点点->断点(再单击一下,断点消失)
  8.   b.右键运行->点击debug运行

day06[方法的重载_面向对象] - 图1

day06[方法的重载_面向对象] - 图2

第二章.类和对象

1.面向对象的介绍

  1. 1.面向对象思想介绍:Java
  2.   自己的事情自己不做,找别人(对象)帮我去做事儿
  3. 2.面向过程:C
  4.   自己每一步都亲力亲为
  5. 3.举例:
  6.   洗衣服:
  7.    面向过程:找盆->放水->洗衣粉->搓衣板->搓搓搓
  8.    面向对象:找洗衣机
  9.   带饭:面向对象
  10.   点外卖:面向对象
  11. 4.总结:
  12.   a.什么是面向对象思想:自己的事情自己不做,找别人(对象)帮我去做事儿
  13.     我们在开发的过程中,我们使用已经被封装好的功能,直接帮我们完成需求
  15.   b.为什么使用面向对象思想?
  16.     为了让实现需求的过程更加的简单
  18.   c.怎么使用呢?
  19.      new 对象  点方法
  21.   d.使用面向对象的目的:
  22.     调用对象中的方法,去帮我们完成需求,怎么实现的,底层不用我们关注
  24. 5.特点:
  25.   由执行者变成了指挥者
  26.   将复杂的事情简单化
  27.   更符合人类思考逻辑->懒
  29. 6.补充:
  30.   如果想要在一个类中使用另外一个类中的成员,就需要使用面向对象思想
  31.      new  点

2.类和对象

2.1类

  1. 1.概述:一类事物的抽象表示形式(先会使用代码去描述世间万物的类,具体在开发中怎么使用,封装部分再说)
  2. 2.定义:
  3.   属性(成员变量)
  4.       定义位置:类中方法外
  5.       作用范围:整个类
  6.       定义格式:数据类型 变量名
  7.       成员变量有默认值:
  8.             整数  0
  9.             小数  0.0
  10.             字符  '\u0000'
  11.             布尔  false
  12.             引用  null
  14.   行为(功能,成员方法):这一类事物都能干啥
  15.      定义时去掉static,其他的方面和之前学的一模一样
  1. public class Person { 
  2.     //属性
  3.     String name;
  4.     int age;
  6.     //成员方法(行为)
  7.     public void eat(){
  8.         System.out.println("人要吃饭");
  9.     }
  11.     public void drink(){
  12.         System.out.println("人要喝水");
  13.     }
  15.     public void la(){
  16.         System.out.println("人要炸坑");
  17.     }
  19.     public void sa(){
  20.         System.out.println("人要嘘嘘");
  21.     }
  22. }
  1. public class Animal {
  2.     //属性
  3.     String name;
  4.     String brand;
  5.     String color;
  6.     int age;
  8.     //成员方法
  9.     public void sleep(){
  10.         System.out.println("睡觉");
  11.     }
  13.     public void jump(){
  14.         System.out.println("跳起来");
  15.     }
  16. }
  1. public class Phone {
  2.     //属性(成员变量)
  3.     String brand;
  4.     String system;
  5.     int price;
  6.     String color;
  8.     //成员方法
  9.     public void call(){
  10.         System.out.println("打电话");
  11.     }
  13.     public void message(){
  14.         System.out.println("发短信");
  15.     }
  16. }

2.2对象

  1. 1.概述:一类事物的具体体现
  2. 2.怎么使用:
  3.   a.导包:import 包名.类名
  4.     如果两个类在同一个包下,使用时无需导包
  5.     如果两个类不在同一个包下,就需要导包了
  7.     lang包下的类使用时无需导包
  9.   b.创建对象:想使用哪个类中的成员,就new哪个类的对象
  10.     类名 对象名 = new 类名()
  12.   c.调用成员:想调用哪个成员,就用哪个类的对象去点哪个成员
  13.     对象名.成员变量名 = 值
  14.     对象名.方法名(参数)
  1. public class Person {
  2.     //属性
  3.     String name;
  4.     int age;
  6.     //成员方法(行为)
  7.     public void eat(){
  8.         System.out.println("人要吃饭");
  9.     }
  11.     public void drink(){
  12.         System.out.println("人要喝水");
  13.     }
  15.     public void la(){
  16.         System.out.println("人要炸坑");
  17.     }
  19.     public void sa(){
  20.         System.out.println("人要嘘嘘");
  21.     }
  22. }
  1. public class Test {
  2.     public static void main(String[] args) {
  3.         Person person = new Person();
  4.         System.out.println(person.name);
  5.         System.out.println(person.age);
  6.         //给属性赋值
  7.         person.name = "柳岩";
  8.         person.age = 36;
  9.         System.out.println(person.name);
  10.         System.out.println(person.age);
  12.         System.out.println("===============");
  13.         person.eat();
  14.         person.drink();
  15.     }
  16. }

3.练习

  1. 需求:用代码去描述一个动物类,在测试类中为动物类中的属性赋值,并且调用动物类中的功能
  1. public class Animal {
  2.     //属性
  3.     String name;
  4.     String brand;
  5.     String color;
  6.     int age;
  8.     //成员方法
  9.     public void sleep(){
  10.         System.out.println("睡觉");
  11.     }
  13.     public void jump(){
  14.         System.out.println("跳起来");
  15.     }
  16. }
  1. public class Test02 {
  2.     public static void main(String[] args) {
  3.         Animal animal = new Animal();
  4.         animal.name = "球球";
  5.         animal.brand = "二哈";
  6.         animal.color = "黑白";
  7.         animal.age = 4;
  8.        System.out.println(animal.name+"..."+animal.brand+"..."+animal.color+"..."+animal.age);
  10.         //调用方法
  11.         animal.sleep();
  12.         animal.jump();
  13.     }
  14. }

总结:

什么时候使用面向对象:一个类想使用别的类的成员

怎么使用: new 呀 点呀

3.匿名对象的使用

  1.  /*
  2.           等号左边Animal  代表的是 对象的类型
  3.           animal  是 对象名
  5.           等号右边new Animal  -> 真正将对象创建出来
  6.          */
  7. Animal animal = new Animal();
  9. 1.概述:没有名字的对象->  new Animal()
  10. 2.使用的时候要注意:
  11.   如果涉及到赋值了,不要用
  12.   如果单纯的想调用一个方法,可以考虑用
  13. 3.总结:
  14.    匿名对象固然好使,但是不要贪杯(开发中尽量别使用)
  1. public class Test01 {
  2.     public static void main(String[] args) {
  3.         //原始方式
  4.         Person person = new Person();
  5.         person.name = "柳岩";
  6.         System.out.println(person.name);
  8.         System.out.println("=================");
  10.         new Person().name = "涛哥";
  11.         System.out.println(new Person().name);
  13.         new Person().eat();
  14.     }
  15. }

day06[方法的重载_面向对象] - 图3

4.一个对象的内存图

  1. public class Phone {
  2.     String brand;
  3.     int price;
  4.     public void call(String name){
  5.         System.out.println("给"+name+"打电话");
  6.     }
  7.     public void message(){
  8.         System.out.println("发短信");
  9.     }
  10. }
  1. public class Test01 {
  2.     public static void main(String[] args) {
  3.         Phone phone = new Phone();
  4.         System.out.println(phone);//地址值
  5.         System.out.println(phone.brand);//null
  6.         System.out.println(phone.price);//0
  7.         phone.brand = "苹果";
  8.         phone.price = 9299;
  9.         System.out.println(phone.brand);//苹果
  10.         System.out.println(phone.price);//9299
  11.         phone.call("柳岩");//给柳岩打电话
  12.         phone.message();//发短信
  13.     }
  14. }

day06[方法的重载_面向对象] - 图4

5.两个对象的内存图

day06[方法的重载_面向对象] - 图5

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

day06[方法的重载_面向对象] - 图6

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

  1. 1.定义位置:重点
  2.   成员变量:类中,方法外
  3.   局部变量:在方法中,或者参数位置
  4. 2.作用范围:重点
  5.   成员变量:整个类都能使用
  6.   局部变量:只能在自己的方法中使用,别的方法使用不了
  7. 3.默认值:重点
  8.   成员变量:有默认值,可以直接使用
  9.   局部变量:没有默认值,需要手动赋值之后才能使用
  11. 4.在内存位置:
  12.   成员变量:在堆中
  13.   局部变量:在栈中
  14. 5.生命周期:
  15.   成员变量:随着对象的创建而产生,随着对象的消失而消失
  16.   局部变量:随着方法的调用而产生,随着方法的执行完毕而消失

第四章.static关键字

1.static的介绍以及基本使用

  1. 1.概述:静态的,关键字
  2. 2.特点
  3.   a.被static修饰的成员随着类的加载而加载
  4.   b.被static修饰的成员由于跟着类到内存,所以优先于对象存在
  5.   c.被static修饰的成员属于类成员,不属于对象成员(成员方法,成员变量)
  6.   d.根据static所在的类创建出来的对象,都会共享这个静态成员
  7. 3.使用:
  8.   类名直接调用

day06[方法的重载_面向对象] - 图7

  1. public class Student {
  2.     int id;
  3.     String name;
  4.     //static String classRoom = "521";
  5.     static String classRoom;
  7.     public static void eat(){
  8.         System.out.println("吃饭");
  9.     }
  10. }
  1. public class Test {
  2.     public static void main(String[] args) {
  3.         //调用静态成员->类名直接调用
  4.         Student.classRoom = "520";
  6.         Student student = new Student();
  7.         student.id = 1;
  8.         student.name = "郭靖";
  9.         //student.classRoom = "520";
  10.         System.out.println(student.id);
  11.         System.out.println(student.name);
  12.         //System.out.println(student.classRoom);
  13.         System.out.println(Student.classRoom);
  15.         System.out.println("=====================");
  17.         Student student2 = new Student();
  18.         student2.id = 2;
  19.         student2.name = "黄蓉";
  20.         //student2.classRoom = "520";
  21.         System.out.println(student2.id);
  22.         System.out.println(student2.name);
  23.         System.out.println(student2.classRoom);
  25.         System.out.println("=============");
  26.         //类名直接调用
  27.         Student.eat();
  28.     }
  29. }

day06[方法的重载_面向对象] - 图8

2.static修饰成员的访问特点

  1. 1.静态的能直接访问非静态成员吗?(成员指的是成员变量,成员方法)
  2.   静态成员:属于类
  3.   非静态成员:属于对象
  5.   静态成员先存在在内存,优先于非静态成员存在
  7.   [不能]
  9.    如果静态的想访问非静态的咋整?
  11.    new对象,调用
  13. 2.非静态成员能直接访问静态成员吗?
  14.   可以
  16.   同类:
  17.     直接调用
  18.     new对象调用
  19.     类名直接调用
  21.   不同类:
  22.     new对象调用
  23.     类名直接调用
  25. 3.静态成员能直接访问静态成员吗?
  26.   可以
  28.   同类:
  29.    直接调用
  30.    new对象调用
  31.    类名直接调用
  32.   不同类:
  33.     new对象调用
  34.     类名直接调用
  36. 4.非静态成员能直接访问非静态成员吗?
  37.   可以
  39.   同类:
  40.    直接调用
  41.    new 对象调用
  42.   不同类:
  43.     new对象调用

总结:

只要是访问非静态成员,不管在不在同一个类中,都可以new对象调用

只要是访问静态成员,不管在不在同一个类中,都可以类名直接调用

第五章.方法参数

  1. 快速将一段代码抽到方法中:ctrl+alt+m

1.基本数据类型做方法参数传递

  1. 基本类型作为方法参数传递的时候
  2. 传递的是值,不是变量本身
  4. 一个方法内部的局部变量的变化,不会影响其他方法中的局部变量
  1. public class Test01 {
  2.     public static void main(String[] args) {
  3.         int a = 10;
  4.         int b = 20;
  5.         method(a,b);
  6.         System.out.println(a);//10
  7.         System.out.println(b);//20
  8.     }
  10.     public static void method(int a, int b) {
  11.         a+=10;
  12.         b+=10;
  13.         System.out.println(a);//20
  14.         System.out.println(b);//30
  15.     }
  16. }

day06[方法的重载_面向对象] - 图9

2.引用数据类型做方法参数传递

  1. 1.参数为引用数据类型时,传递的是地址值
  2.   所以一个方法内部引用类型的值改变了,会影响到其他方法中的这个引用类型的值
  1. public class Test02 {
  2.     public static void main(String[] args) {
  3.         int[] arr = {10,20};
  4.         method(arr);
  5.         System.out.println(arr[0]);//20
  6.         System.out.println(arr[1]);//30
  7.     }
  9.     public static void method(int[] arr) {
  10.         arr[0]+=10;
  11.         arr[1]+=10;
  12.         System.out.println(arr[0]);//20
  13.         System.out.println(arr[1]);//30
  14.     }
  15. }

day06[方法的重载_面向对象] - 图10

String做方法参数传递比较特殊:单记(字符串在底层是一个被final修饰的数组,字符串定义之后,在内存中无法改变)