Java编程基础阶段笔记 day 07 面向对象编程(上)

大数据港-王庆港 2019-08-05

编程语言 java 面向对象 面向对象编程 排序 string 编程 void 数据类型 数组

  • 面向对象编程

笔记Notes

面向对象三条学习主线

面向过程 VS 面向对象

类和对象

创建对象例子

面向对象的内存分析

类的属性:成员变量

成员变量 VS 局部变量

类的方法

方法的重载

可变个数形参

面向对象:封装性

访问权限修饰符

构造方法(构造器)

给属性赋值的方法

UML类图

this 关键字


面向对象学习主线

类及类的成员:属性,方法,构造器,代码块,内部类

面向对象的三大特性:封装性,继承性,多态性

其他关键字:this,super,interface,final,static......

面向过程 vs 面向对象

面向过程:强调的是功能行为

面向对象 :强调具备了功能的对象

类和对象的区别

类:抽象的(汽车设计模板)

对象:具体的,类的实例(根据模板造出的汽车)

类的成员:属性和方法

属性 = field = 成员变量

(成员)方法 = 函数 = method

面向对象的例子

1.创建一个类,并在类中提供必要的属性和方法

2.由类派生出对象。(创建对象)

3.调用对象中的属性和方法。(对象名.属性名/方法名)

         //创建一个类

class Person{

      //属性

      String name;

      int age;

      char sex;

      

      //方法

      public void run(){

               System.out.println(name + "跑起来");

      }

      

      public void say(){

               System.out.println(name + "今年" + age);

      }

}

// main 方法中

               Person person = new Person();

               //调用属性 :对象名.属性名

               person.name = "王庆港"; //给属性赋值

               person.age = 23;

               //获取属性的值

               String name = person.name;

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

               //调用方法 :对象名.方法名

               person.run();

               person.say();

面向对象的内存分析

同一个类创建的多个对象,每个对象独自拥有一份属性。

当修改其中一个对象的属性的值后,其它对象的该属性不会受到影响

类的成员之 :属性(成员变量)

变量的分类:

①按照数据类型分 :基本数据类型 vs 引用数据类型

②按照位置分 :成员变量 vs 局部变量

成员变量和局部变量 相同点:

①变量的声明的格式都是一样的。

②变量都有作用域

③变量都是先声明后使用

成员变量和局部变量 不同点:

①局部变量:在方法里,方法的形参,构造器中,构造器的形参,代码块

②成员变量: 在类中方法等结构外

权限修饰符:

①局部变量:不能使用权限修饰符修饰

②成员变量:可以使用四种权限修饰符(public protected 缺省的(default) private)

内存:

①局部变量:在内存的栈中

②成员变量:在内存的堆(对象)中

默认值:

①局部变量 :没有默认值

②成员变量 :有默认值(和数组元素的默认值是一样的)

byte,short,int,long -> 0

float,double -> 0.0

boolean -> false

char -> u0000

引用数据类型 -> null

class Animal{

      //属性(成员变量)

      public String name = "动物";

      int legs;

      protected boolean isLive = true;

      {//代码块

               String address = "";//局部变量

      }

      public Animal(){} 

      //构造器

      public Animal(int sex){//构造器的形参

               int a = 10;//局部变量

      }

      //方法

      public void say(int sex){//方法的形参

               //局部变量

               int age = 10;

               age = 20;

               name = "大锤";

      }

}

不定义对象的句柄,而直接调用这个对象的方法。这样的对象叫做匿名对象。

如:new Person().shout();

类的成员:方法(method)

Java里的方法不能独立存在,所有的方法必须定义在类里。

方法的声明格式:

修饰符 返回值类型 方法名(参数类型 形参1, 参数类型 形参2, ….){

方法体程序代码

return 返回值;

}

权限修饰符 :public protected 缺省的 private (先用public)

①void/具体的类型(基本数据类型、引用数据类型):

②void : 表示该方法没有返回值

具体的类型 :调用该方法会有返回值。

注意:返回数据需要使用return关键字。return 后面跟需要返回的数据。

方法名 :只需要遵守标识符的规则和规范即可

(形参相同的情况下,同一个类中的方法名不能相同)。

形参列表 :可以有0个1个或多个。多个之间使用","隔开。

①作用 :用来通知方法的调用者调用此方法时需要传递数据。

②注意:实参的类型必须和形参的类型保持一致

方法体 :方法功能的具体体现。

注意 :只有调用方法时方法体才会执行。

对象数组题目:

定义类Student,包含三个属性:学号number(int),年级state(int),成绩score(int)。创建20个学生对象,学号为1到20,年级和成绩都由随机数确定。

问题一:打印出3年级(state值为3)的学生信息。

问题二:使用冒泡排序按学生成绩排序,并遍历所有学生信息

提示:

1) 生成随机数:Math.random(),返回值类型double;

2) 四舍五入取整:Math.round(double d),返回值类型long。

class Student1{

      int  number;

      int state;

      int score;

      

      @Override

      public String toString() {

               return "Student1 [number=" + number + ", state=" + state + ", score=" + score + "]";

      }

      

}

public class StuInfo {

      public static void main(String[] args) {

               // 创建对象数组

               Student1[] studentArr = new Student1[20];

               // 循环创建对象并赋值,传给对象

               

               for (int i = 0; i < 20; i++) {

                         Student1 student1 = new Student1();

                         student1.number = i;

                         student1.state = (int)Math.round( (Math.random()*7));

                         student1.score = (int) (Math.random()*100);   

                         studentArr[i] = student1;

               }

               System.out.println("---------打印排序前的学生信息-------------");

               for (int i = 0; i < studentArr.length; i++) {

                         System.out.println(studentArr[i]);

               }

               

               System.out.println("----------打印state为3的学生信息---------");

               // 循环查找对象数组中state值为3的对象,打印输出对象信息

               for (int i = 0; i < studentArr.length; i++) {

                         if (studentArr[i].state == 3) {

                                  System.out.println(studentArr[i]);

                         }

               }

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

               // 使用冒泡排序按学生成绩排序,并遍历所有学生信息

               // 思路:两个循环遍历数组中的对象的成绩,若对象的成绩小于后一个,则交换对象的位置

               for (int i = 0; i < studentArr.length -1; i++) { // 外层循环决定冒泡排序的次数,为数组长度-1

                         for (int j = 0; j < studentArr.length - i -1; j++) { // 内层循环决定每次多少次冒泡,为

                                  if (studentArr[j].score > studentArr[j+1].score) { // 如果前面的对象小于大于后面的,就叫交换类数组地址

                                            Student1 temp = studentArr[j];

                                            studentArr[j] = studentArr[j+1];

                                            studentArr[j+1] = temp;

                                  }

                         }

               }

               // 注意!!!!!!!!!!

               // 冒泡排序交换的值的数组的下标为内循环的循环变量

               System.out.println("------打印排序后的信息-------");

               // 打印排序后的信息

               for (int i = 0; i < studentArr.length; i++) {

                         System.out.println(studentArr[i]);

                                  

               }

               

      }

}

重载的概念、特点、实例

①在同一个类中,允许存在一个以上的同名方法,只要它们的参数个数或者参数类型不同即可。

②与返回值类型无关,只看参数列表,且参数列表必须不同。

(参数个数或参数类型)。调用时,根据方法参数列表的不同来区别。

③示例:

//返回两个整数的和

int add(int x,int y){return x+y;}

//返回三个整数的和

int add(int x,int y,int z){return x+y+z;}

//返回两个小数的和

double add(double x,double y){return x+y;}

注意!!:

①不同的形参列表 :形参的个数,顺序,类型不同

②方法的重载和权限修饰符,返回值类型,形参的名字无关。

③判断方法:只看 方法名 + 形参列表(看形参和实参的类型)

可变个数形参

格式 :变量的类型 ... 变量名

说明:

             ①可变形参的底层就是一个数组

             ②在可变形参的方法中,和可变形参相同类型的数组的方法不构成重载。

             ③在形参列表中可变形参只能放在最后

             ④在同一个方法的形参列表中只能有一个可变形参。

             ⑤ 可变形参的个数可以是0个1个或多个

方法的参数传递

基本数据类型的参数传递

引用数据类型的参数传递

方法的参数传递

面向对象:封装

为什么要使用封装性?

在创建对象以后,就可以通过对象名.属性名这种方式对属性直接进行操作。这种操作对于属性只有类型和范围的限制。但是在实际开发中我们会有更多的其它的限制条件。而这些限制条件又不能在属性的声明处加以限制。我们采取取如下方式

①使用权限修饰符对属性进行权限的限制,那么在类的外部就不能随意的再调用类中的属性

②提供公共的方法,在方法中可以加以限制其它的条件。然后可以通过该方法给属性赋值和获取属性的值。

封装性的体现(狭义上):

①将属性私有化。(private修饰属性)

②提供公共的set/get方法。(set方法用来给属性赋值,get方法用来获取属性的值)

封装性的体现(广义上):

①可以使用四种权限修饰符:private,缺省的,protected,public

②四种权限修饰符可以修饰 :属性,方法,构造器,内部类

③类只能被public和缺省的修饰。

四种访问权限修饰符

构造方法(构造器)

构造器的特征

它具有与类相同的名称

它不声明返回值类型。(与声明为void不同)

不能被static、final、synchronized、abstract、native修饰,不能有return语句返回值

构造器的作用:创建对象;给对象进行初始化

如:Order o = new Order(); Person p = new Person(“Peter”,15);

根据参数不同,构造器可以分为如下两类:

隐式无参构造器(系统默认提供)

显式定义一个或多个构造器(无参、有参)

注 意:

Java语言中,每个类都至少有一个构造器

默认构造器的修饰符与所属类的修饰符一致

一旦显式定义了构造器,则系统不再提供默认构造器

一个类可以创建多个重载的构造器

父类的构造器不可被子类继承

构造器重载使得对象的创建更加灵活,方便创建各种不同的对象。

给属性赋值的方法

赋值的位置:

① 默认初始化:int a;

② 显式初始化:int a = 0;

③ 构造器中初始化

④ 通过“对象.属性“或“对象.方法”的方式赋值

赋值的先后顺序:

① - ② - ③ - ④

JavaBean:Java语言编写的可重用组件

定义:是一个普通的Java类,但是符合如下标准

①类是公共的

②有一个无参的公共的构造器

③有属性,且有对应的get、set方法

UML类图

①+ 表示 public 类型, - 表示 private 类型,#表示protected类型

②方法的写法:方法的类型(+、-) 方法名(参数名:参数类型):返回值类型

this 关键字

this 是什么?

①它在方法内部使用,即这个方法所属对象的引用;

②它在构造器内部使用,表示该构造器正在初始化的对象。

this作用域:this 可以调用类的属性、方法和构造器

适用情形:当在方法内需要用到调用该方法的对象时,就用this。

具体的:我们可以用this来区分属性和局部变量。

public void setAge(int age){

       age = age;//局部变量 :就近原则(属性名和局部变量名相同时默认调用的是局部变量)

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

}

this 调用构造器

总结Summary

面向对象的内存分析

成员变量与局部变量

构造器

函数重载

登录 后评论
下一篇
冒顿单于
11611人浏览
2019-08-28
相关推荐
对零基础java学习者的建议
391人浏览
2018-07-12 14:23:00
Java 学习路线之四个阶段
834人浏览
2018-05-18 20:17:00
0
0
0
114