Java笔记----第六章(VI) 类和对象

一、面向对象

1.面向对象编程实现过程

2.面向对象三大特性

1.封装： 封装就是把数据和对数据的操作封装在一起。封装将数据隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。
2.继承： 继承实现了一种先进的编程模式。继承是指子类可以继承父类的属性和行为，同时又可以新增自己的属性和行为。
3.多态： 多态具有表现多钟形态的能力的特征。

二、类

1.类的含义

类是模板，定义了一组对象所具有的共同的属性和行为，类是组成Java程序中基本的要素，是Java语言中最基本的单元。

2.类的定义

(1) 类的结构

//基本结构
public class 类名{
    
    
//属性描述---使用成员变量描述
   变量类型 变量1;
   变量类型 变量2;
   ......
//行为描述---使用成员方法实现
   方法1定义;
   方法2实现;
}

*类名要求：
类名必须是合法的Java标识符（语法要求），同时类名要遵守以下命名规范（不是语法要求，但应当遵守：）
（1）类名首写字母要大写；如果多个单词组成，每个单词的首写字母都大写，如Person、Student、HelloJava等。
（2）类名尽量容易识别，见名知意。

(2) 变量

成员变量

1. 成员变量含义: 类体中描述属性的变量称他们为成员变量，它是出现在类体的内部，方法的外部。
2.成员变量语法格式: [修饰符] 数据类型 变量名 [=值] ;
(1) 修饰符是表示该变量的访问权限，用括号括起来说明它不是变量必须的。
(2) 成员变量的数据类型可以是Java中的任何一种数据类型，包括基本数据类型：整型、浮点型、字符型、逻辑型；引用数据类型：数组、类和接口。
注意：成员变量的作用域在整个类体内有效，相当于我们说的全局变量。
(3) 成员变量的名字跟类名一样必须是合法的Java标识符（语法要求），同时变量名要遵守以下命名规范（不是语法要求，但应当遵守：）
* 变量名首写字母要小写，如果多个单词组成，每个单词的首写字母都要后面的每个单词的首写字母都大写。如：name、numberOfStudent等。
* 变量名一般用名词表示，也是尽量见名知意。
(4)成员变量可以不显示初始化，这时系统会赋给默认值，不同数据类型，系统赋以默认值不同。

成员变量类型	初始值
byte	0
short	0
int	0
long	oL
float	0.0F
double	0.0D
char	空字符，‘\u0000’
boolean	false
引用数据类型	null

局部变量

1.局部变量含义: 类的方法体中声明的变量和方法的参数被称作局部变量。

*成员变量与局部变量区别

(1) 成员变量使用时可以不显示赋值，系统会赋给默认值，而局部变量使用前必须初始化。
(2) 成员变量的作用域是在类体内，而局部变量的作用域只限制在方法体内。

(3)类的方法和重载

类的方法

类的方法：
1.成员方法 类的行为是用方法来描述的，类体中定义的方法被称为成员方法 。
方法的定义: 包括方法声明和方法体。

方法的定义语法格式如下：

 [修饰符] 返回类型 方法名（[参数列表]）{
    
    
 // 方法体，可以是任意合法的Java语句
}

(1) 修饰符: 我们现在用的是public，代表该方法的访问权限为公共的。
(2) 返回类型： 方法返回类型可以是Java中任何一种数据类型，当声明方法有返回值时，必须有return语句，并且返回类型跟声明的类型一致。当方法不需要返回值时，返回类型为void。
(3) 方法名： 方法名字命名跟变量名字一样，也必须是合法的Java标识符（语法要求），同时要遵守以下命名规范（不是语法要求，但应当遵守）：
* 方法名首写字母要小写，如果多个单词组成，后面每个单词的首写字母都大写，如getLNfo，print等。
* 方法名一般用动词表示，尽量见名知意。
(4) 参数列表： 小括号中参数列表可以是零个到多个，多个参数用逗号隔开。
(5) 方法体： 方法体中可以包括局部变量定义和任何合法的Java语句，即在方法体内可以对成员变量和方法体中声明的局部变量进行操作。

扫描二维码关注公众号，回复： 12254513 查看本文章

方法重载

含义： 在Java中一个类里面允许有多个同名的方法，为了区分同名的方法，要求方法的参数列表必须不同，所谓的参数列表不同是指或者参数的个数不同，或者是参数的类型不同，方法的返回类型和参数名字不参与比较，这称之为方法重载。

案例：(注意：整个代码总体来看)

public class MethodOverLoading{
    
    
      public void print(){
    
    
            System.out.println("无参方法);
      }
      public void print(String s){
    
    
            System.out.println(s);
      }
      //参数名字和返回类型不参与比较，所以下面的方法不是重载方法！
      public void print(String name){
    
    
      }
      public int print(String age){
    
    
                   return age;
      }
}

(4)类的构造方法

构造方法的特别之处在于构造方法的名字必须跟类名相同，而且没有返回类型（既没有返回值，也没有返回类型）

语法格式为：

[修饰符] 类名 （参数列表）{
    
    
  //方法体;
}

注意：
（1） 当一个类中没有编写构造方法时，系统会默认提供一个无参构造方法，且方法体中没有语句。

（2） 构造方法也可以重载。

//举例：
public class Student{
    
    
     public Student(){
    
       //方法体
     }
     public Student(String name,int age){
    
      //方法体
     }
}

（3） 如果在类体中定义了参数非空的构造方法，那么Java就不再显示提供的默认的无参构造方法。要想使用默认的无参构造方法，必须显示的写出来。

注意：
在类体中完了变量又单独给变量赋值，或者直接在类体中学输出语句、if语句、循环语句等，这都是错误的，编译不会通过。

//举例
public class Student{
    
    
     String name;  //姓名属性
     int age;  //年龄属性
     age=20;  //编译通不过
     if(age<0){
    
    }  //编译通不过
     if(){
    
    }  //编译通不过
     System.out.print();  //编译通不过
}

三、对象

一个类可生多个对象，所以使用类创建对象的过程等价于变量定义的过程。

1.使用类创建对象分为三步

(1)声明对象(等价于变量声明）
语法格式： 类名 对象名；<==> 数据类型 变量名；
如：用Student类来声明两个对象：stuOne、stuTwo，格式为：
Student stuOne,stuTwo; < = = > int a,b ;
(2)创建对象:(等价于为变量赋值)
为对象赋值需要使用new运算符，同时要调用构造方法。
语法格式：对象名=new 构造方法；< = = > 变量名=值；
例：对于前面声明的stuOne对象，可以这样赋值:
stuOne = new Student(); //调用无参构造方法
stuOne = new Student(“小刚”，18，“数学系”); //调用有参的构造方法
*注 声明对象和创建对象可以在一条语句中完成：
Student stuOne = new Student(); < = = > int a=10;
(3)对象的使用:(等价于变量使用)

四、封装

1.封装的含义： 所谓封装，就是指使用private修饰成员变量，private是私有的意思，它修饰的成员变量只能在类体内被引用，如果外界想要访问私有属性，需要提供一些属于public修饰的共有方法，其中包括用于获取属性值得getXxx方法和设置属性值得setXxx方法。简言之，就是“属性私有化，方法公有化”。
2.封装的用途： 在Java中，通过对类的封装来解决出现不符合现实逻辑的问题。Java语言中提供了private、默认的、protected和public四个访问限制修饰符来限制用户访问权限。

案例：

//在Student类包中
package class Student{
    
    
//属性定义
   private String name;
//setter方法，setter作用是为属性赋值
   public void setName(String name1){
    
    
       name=name1;
   }
//getter方法，作用是为属性取值
   public String getName(){
    
    
       return name;
   }   
}

//在main函数中
public class Student{
    
    
    public static void main(String[] args){
    
    
       //1.声明对象
       Student stuOne;
       //2.为对象赋值
       stuOne = new Student();
       //3.使用对象
       stuOne.setName("小明");  //调用setter方法
       System.out.println(stuOne.getName()); //调用getter方法
    }
}

五、static关键字

static关键字的作用：当想要设置某些特定的数据在内存中只有一份，而且能够被一个类的所有实例对象都共享时，这时就需要用到static。

例：(令某个学校所以学生共享一个学校名称)
图：

1.静态变量

静态变量：在一个Java类中，可以使用static关键字来修饰成员变量，该变量被称作静态变量，也叫类变量。静态变量是一块公共内存，跟类绑定，被所有实例共享，可以使用“ 类名.变量名 ”的形式来访问。

例：

package p5;
   class Student{
    
    
      static String schoolName; //定义静态变量
}
public class EX6_3{
    
    
   public static void main(String[] ages){
    
    
       Student.schoolName="滨州学院";
       Student stuOne=new Student();
       System.out.println("stuOne的学校是"+stuOne.schoolName);
   }     
}
运行结果：
stuOne的学校是滨州学院

2.静态方法

静态方法：static关键字还可以修饰方法，被static修饰的方法被称作静态方法，也叫类方法。跟静态变量一样，静态变量不必和对象绑在一起，可以使用“ 类名.方法名 ”的方式来访问。

例：

package p5;
   class Student{
    
    
      static String schoolName; //定义静态变量
      /定义静态方法
      static void sayHello(){
    
    
           System.out,println("大家好！");
      }
}
public class EX6_3{
    
    
   public static void main(String[] ages){
    
    
       Student stuOne=new Student();
       Student.sayHello();  //利用类名调用
       stuOne.sayHello();  //利用对象名调用
   }     
}

运行结果:
大家好！
大家好！

六、this关键字

1.在构造方法中使用this：
this关键字出现在构造方法中，谁来使用该构造方法创建对象，this就指代谁。
2.在实例方法中使用this：
当this关键字出现在实例方法中时，this代表正在调用该方法的当前对象。
3.注意：
(1)无论在构造方法中还是实例方法，但是当方法内有同名的局部变量时，this不能省略。
(2)this关键字不可以出现在静态方法中因为静态方法与类关联，所有对象共享，无法用this指代当前对象。

七、包

1.包的创建

通过关键字package声明包语句。package语句作为Java源文件的第一条语句，指明该源文件定义的类所在的包。package声明语句语法格式为：
package 包名；

例：

package cn.edu.bzu;
public class Student(){
    
    
}

2.包命名规范

包名由小写字母组成，不能以圆点开头或结尾。自己设定的包名之前最好加上唯一的前缀，通常使用组织倒置的网络域名。(这是一个约定俗成的东西，并不是硬性的事情。)

3.包的使用

为了使用不在同一包中的类，需要在Java程序中使用import关键字导入这个类，导入格式有以下两种：
import 包名.* ; //该包下所有的类都可以被引用
inport 包名.类名; //只能引用类名指定的类
例：(以Student 为例)
import cn.edu.bzu.Student
注: 同一包中的类不需要导入，直接可以使用。

4.特殊的包：Java.lang 包

Java.lang 包是Java语言的核心类库，它包含了运行程序必不可少的系统类，系统自动为程序引入Java.lang 包中的类（Sysem、String等），不需要使用import引入就可以使用，所以之前的开发使用System、String，但是没有写import语句。

八、UML类图

1.类图

在UML中，类图使用包含类名，属性和操作且带有分隔符线的长方形来表示。

(1) 类图第一层是类名，类名如果是常规字型，表明该类是具体类，如果是斜体字型，表明该类是抽象类。
(2)类图第二层是属性层，也称变量层 。列出类的成员变量及类型。UML规定变量的表示方式为：可见性 变量名字：类型[=缺省值]
其中：
*“可见性”表示该变量对于类外的元素可言是否可见，包括共有（public）、私有（private）和受保护（protect）三种，在类图中分别用符号+、- 和 # 表示。
*“缺省值”是一个可选项，即变量的初始值。
(3) 类图第三层是方法层，也称操作层，列出类中的成员方法。UML规定操作表示方法为：可见性 名称(参数列表) [ : 返回类型]
其中：
*“可见性”的定义与属性的可见性定义相同。
*“名称”即方法名。
*“参数列表”表示方法的参数，其语法与属性的定义相似，参数个数是任意的，多个参数之间用逗号“ ，”隔开。
*“返回类型”是一个可选项，表示方法的返回值类型，可以是基本数据类型，也可以是引用数据类型，还可以是空类型（void），如果是构造方法，则无返回类型。

2.类与类之间的关系

在UML图中，类与类之间有以下几种关系：泛化（Generalization）、实现（Realization）、关联（Association）、聚合（Aggregation）、组合（Composition）、依赖（Dependency）。

(1)泛化：
含义：泛化关系是指类之间的继承关系，表示一般与特殊的关系。
例：教师（Teacher）和学生（Student）都是人类。
具体表现：class子类 exdends父类{ }
图示：空心箭头+实线，箭头指向父亲。

(2)实现：

含义：实现关系是指类与接口的关系，表示类实现接口所有属性和行为。
具体表现：class类名 implements 接口名{ }
图示：空心三角箭头+虚线，箭头指向接口。

(3)关联：
含义：对于两个相对独立的对象，当一个对象的实例与另一个对象的一些特定实例存在固定的对应关系时，这两个对象之间为关联关系。关联又分为一般关联、聚合关联与组合关联。
具体表现：成员变量
图示：普通箭头+实线，箭头从使用类指向被关联的类。

(4)聚合：
含义：聚合关系是关联关系的一种，是强的关联关系；表示是整体与部分的关系，且部分可以离开整体而单独存在。
例：车与方向盘之间的关系。
具体表现：成员变量
图示：空心菱形+实心线，箭头指向整体。

(5)组合：
含义：组合关系是关联关系的一种，是比聚合关系还要强的关系，它要求普通的聚合关系中代表整体对象负责代表部分的对象的生命周期。组合关系也表示整体与部分的关系，但部分不能离开整体而单独存在。
例：人和大脑是整体和部分的关系。
具体表现：成员变量
图示：空心菱形+实线，箭头指向整体。

(6)依赖：
含义：依赖关系是一种使用的关系，即一类的实现需要另一个类的协助，所以要尽量不使用双向的互相依赖。
具体表现：局部变量、方法的参数或者对静态方法的调用
图示：普通箭头+虚线，箭头指向被使用者。
.