面向对象

面向过程：当需要实现一个功能的时候，每一个具体的步骤都要亲历亲为，详细处理每一个细节

面向对象：当需要实现一个功能的时候，不关心具体的步骤，而是找一个已经具有该功能的人来帮我做事

public class Demo01PrintArray { public static void main(String[] args) { int[] array = {10, 20, 30, 40, 50}; //要求打印格式为：[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("============"); //使用面向对象，找一个JDK给我们提供好的Arrays类 //其中有一个toString方法，直接就能把数组变成想要的格式的字符串 System.out.println(Arrays.toString(array)); } }

类与对象的关系

类是对一类事物的描述，是抽象的

对象是一类事物的实例，是具体的

类是对象的模板，对象的类是实体

定义一个类，用来模拟“学生”事物，其中有两个组成部分：

属性（是什么）：

         姓名

         年龄

行为（能做什么）：

         吃饭

         睡觉

         学习

对应到Java的类当中：

成员变量（属性）：

       String name ; //姓名

       int age ; // 年龄

成员方法（行为）：

        public void eat( ){ }  //吃饭

        public void sleep( ){ }  //睡觉

        public void study( ) { }  //学习 

public class student { //成员变量 String name; int age; //成员方法 public void eat(){ System.out.println("吃饭饭！"); } public void sleep(){ System.out.println("睡觉觉！"); } public void study(){ System.out.println("学习！"); } }

注意事项：

成员变量是直接定义在类当中的，在方法外边

成员方法不要写static关键字

 

通常情况下，一个类并不能直接使用，需要根据类创建一个对象才能使用

1.导包：也就是指出需要使用的类在什么位置

import 包名称 . 类名称；

import cn.itcast.day0701.demo01.Student；

对于和当前类属于一个包的情况，可以省略导包语句不写

2.创建格式：

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

Student stu = new Student()；

3.使用分为两种情况

使用成员变量：对象名.成员变量名

使用成员方法：对象名.成员方法名（参数）；

public class Demo02Student { public static void main(String[] args) { //1.导包 //我需要使用的Student类，和我自己Demo02Student位于同一个包下，所以省略导包语句不写 //2.创建：类名称 对象名 = new 类名称（）； //根据Student类，创建了一个名为stu的对象 student stu = new student(); //3.使用其中的成员变量：对象名.成员变量名 System.out.println(stu.name);//null System.out.println(stu.age);//0 System.out.println("==============="); //改变对象当中的成员变量数值内容 //将右侧的字符串赋值交给stu对象当中的name成员变量 stu.name = "宋智孝"; stu.age = 18; System.out.println(stu.name);//宋智孝 System.out.println(stu.age);//18 //4.使用对象的成员方法：对象名.成员方法名（） stu.eat();//吃饭饭！ stu.sleep();//睡觉觉！ stu.study();//学习！ } }

注意事项：如果成员变量没有进行赋值，那么将会有一个默认值，规则和数组一样

定义一个类，用来模拟“手机”事物

属性：品牌、价格、颜色

行为：打电话、发短信

对应到类当中：

成员变量（属性):

      String brand ; //品牌

      double price ; //价格

      String color ; //颜色

成员方法（行为）：

      public void call (String who ) { } //打电话

      public void sendMessage ( ) { } //群发短信

public class phone { //成员变量 String brand;//品牌 double price;//价格 String color;//颜色 //成员方法 public void call(String who){ System.out.println("给" + who + "打电话"); } public void sendMessage(){ System.out.println("群发短信"); } } public class Demo01phoneOne { public static void main(String[] args) { //根据phone类创建一个名为one的对象 //格式：类名称 对象名 = new 类名称（）; phone one = new phone(); System.out.println(one.brand);//null System.out.println(one.price);//0.0 System.out.println(one.color);//null System.out.println("==========="); one.brand = "苹果"; one.price = 8888.0; one.color = "黑色"; System.out.println(one.brand);//苹果 System.out.println(one.price);//8888.0 System.out.println(one.color);//黑色 System.out.println("==========="); one.call("谢可寅");//给谢可寅打电话 one.sendMessage();//群发短信 } }

内存图

使用对象类型作为方法的参数

public class Demo02phoneParam { public static void main(String[] args) { phone one = new phone(); one.brand = "苹果"; one.price = 8888.0; one.color = "土豪金"; method(one); } public static void method(phone param){ System.out.println(param.brand); System.out.println(param.price); System.out.println(param.color); } }

局部变量和成员变量

定义的位置不一样

        局部变量：在方法的内部

        成员变量：在方法的外部，直接写在类当中

作用范围不一样

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

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

默认值不一样

       局部变量：没有默认值，如果想要使用必须手动进行赋值

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

内存的位置不一样

      局部变量：位于栈内存

      成员变量：位于堆内存

生命周期不一样

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

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

面向对象三大特征：封装、继承、多态

封装性在Java当中的体现：

1.方法就是一种封装

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

封装就是将一些细节信息隐藏起来，对于外界不可见

 

问题描述：定义Person的年龄时，无法阻止不合理的数值被设置进来

解决方案：用private关键字将需要保护的成员变量进行修饰

一旦使用了private进行修饰，那么本类当中仍然可以随意访问

但是超出了本类范围之外就不能再直接访问了

间接访问private成员变量，就是定义一对儿Getter/Setter方法

命名规则：必须叫setXxx或者getXxx  

对于Getter来说，不能有参数，返回值类型和成员变量对应

对于Setter来说，不能有返回值，参数类型和成员变量对应

public class Person { String name; private int age; public void show(){ System.out.println("我叫：" + name + ",年龄：" + age); } //这个成员方法，专门用于向age设置数据 public void setAge(int num){ if(num < 100 && num >=0){ age = num; } else{ System.out.println("数据不合理！"); } } //这个成员方法，专门用于获取age的数据 public int getAge() { return age; } } public class Demo03Person { public static void main(String[] args) { Person person = new Person(); person.show(); person.name = "宋智孝"; //间接访问 person.setAge(20); person.show(); } }

对于基本类型当中的boolean值，Getter方法一定要写成isXxx的形式，而setXxx规则不变

当方法的局部变量和类的成员变量重名的时候，根据”就近原则“，优先使用局部变量

如果需要访问本类当中的成员变量，需要使用格式：this.成员变量名

public class Person { String name;//我自己的名字 //参数name是对方的名字 //成员变量name是自己的名字 public void sayHello(String name){ System.out.println(name + "，你好。我是" + this.name); } } public class Demo01Person { public static void main(String[] args) { Person person = new Person(); //设置我自己的名字 person.name = "王健林"; person.sayHello("王思聪");//王思聪，你好。我是王健林 }

通过谁调用的方法，谁就是this

构造方法

构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法

格式：

public 类名称（参数类型  参数名称）{

      方法体

}

注意事项：

构造方法的名称必须和所在的类名称完全一样，就连大小写也要一样构造方法不要写返回值类型，连void都不写构造方法不能return一个具体的返回值如果没有编写任何构造方法，那么编译器将会默认赠送一个构造方法，没有参数、方法体什么事情都不做

        public Student( ) { }

一旦编写了至少一个构造方法，那么编译器将不再赠送构造方法也是可以进行重载的

       重载：方法名称相同，参数列表不同

一个标准的类通常要拥有下面四个组成部分：

所有成员变量都要用Private关键字修饰为每一个成员变量编写一个对Getter/Setter方法编写一个无参数的构造方法编写一个全参数的构造方法

这样标准的类也叫做Java Bean

public class Demo05Student { public static void main(String[] args) { Student stu1 = new Student(); stu1.setName("谢可寅"); stu1.setAge(20); System.out.println("姓名：" + stu1.getName() + ",年龄" + stu1.getAge()); System.out.println("============"); Student stu2 = new Student("宋智孝",21); System.out.println("姓名：" + stu2.getName() + ",年龄" + stu2.getAge()); stu2.setAge(22); System.out.println("姓名：" + stu2.getName() + ",年龄" + stu2.getAge()); } }