一、封装的概念

将字段（C结构体中的属性）和方法（C结构体中的函数）包装进类中，加上具体实现的隐藏（访问修饰符），共同被称作为封装，其结果是一个同时带有特征和行为的数据类型。

定义类，定义其属性、方法的过程称为封装类。

学会从C语言的结构体中转换概念：

struct Student
{int age;   //类似与java中的属性  特征char* name;void (*introduce)(int age,int name,int score); //函数 = 方法void (*testFunc)();
};

二、类的封装以及使用

//封装一个类
class Student //写规范来，第一个字母大写
{int age;       //特征String name; //JAVA中没有char*double score;void introduce(){   // 方法 = C语言中的函数System.out.println("my name is"+name  +  "age:"+age   +  "score"+score);}    //面向对象的特性就是方法可以访问本类的特征属性，不需要额外的去传参void testFunc(){System.out.println("testFunc");}
}//怎么使用这个类呢？
public class Demo1 {public static void main(String[] args) {Student stu1 = new Student(); //这操作叫实例化一个对象//类 = 模板，类不能直接使用，不能直接访问变量，需要先实例化，申请一个空间。//改成Student stu1 = null，好比C语言的指针使用前不malloc开辟空间/*这操作就等同于在c语言中，我们对结构体指针的定义及访问struct Student* p;p = malloc(sizeof(struct Student));*/stu1.age = 18;stu1.score = 99.5;stu1.name = "小明"; //不需要像C语言中strcpy赋值stu1.introduce();}
}

其中比较重要的概念：

面向对象的特性就是方法可以访问本类的特征属性，不需要额外传参

三、访问修饰符

访问修饰符用于信息隐藏，是OOP（Object Oriented Programming面向对象的编程）重要的功能。

隐藏信息的原因：

（1）对模块的任何实现细节所做的更改不会影响使用该模块的代码
（2）防止用户意外修改数据
（3）使模块易于维护和使用（就是电脑配件）
（4）规范方法，特征的使用空间

访问修饰符：访问权限（通过“.”来访问），可以看到private是最严格的：

位置	private	默认	protected	public
同一个类	是	是	是	是
同一个包(文件)内的类	否	是	是	是
不同包内的子类	否	否	是	是
不同包且不是子类	否	否	否	是

权限怎么理解呢？

下面就以 “只有正确输入银行卡密码才能读取银行卡信息” 为例子

四、属性封装的实现

封装属性：修改属性的可见性来限制对属性的访问。

为每个属性创建一对赋值方法（getter）和取值（setter）方法，用于公开对这些属性的访问接口，在getter和setter方法中，根据需要加入对属性操作的限制。

举一个最简单的例子：

public class Student {private  String  name; //可以通过下面的方法间接访问隐私属性public void setName(String name){this.name = name;}public String getName(){return  name;}
}

五、方法封装的实现

方法封装的目的：隐藏方法实现细节（方法体），向外部提供公开接口（方法头），以供安全调用；简化调用，方便修改维护；可以私有化方法，以提供内部使用——帮助方法helper。

先设置自己的真实年龄为36岁，当别人当面问你多少岁时，通过“封装的”不对外公开的方法修改了自己的真实年龄，再告诉他我18岁。

但是如果直接访问简历上的年龄，通过这个方法访问到的就是真实年龄36岁

class Age//注意这个类的名字第一个大写（好习惯），不能跟下面的age一样
{private int age;void setAge(int realAge){age = realAge;}private void tellAlie(int falseAge){age = falseAge;}void askMyAge()//当别人问我的姓名  假{tellAlie(18);  //外部不知道这个方法的存在System.out.println("别人问我我就说我永远"+age);}void resumeAge()  //真{System.out.println("简历上是真实年龄:"+age);}
}
public class Demo3 {public static void main(String[] args) {Age a1 = new Age();a1.setAge(36);a1.resumeAge();//通过这个方法访问到的是真实年龄a1.askMyAge(); //不对外公开的方法修改了真实年龄}
}

六、UML类图

UML-Unified Modeling Language 统一建模语言，又称标准建模语言。

（1）类的命名尽量采用应用领域内的术语。

（2）类的属性、操作中的可见性用+ # -分别表示public protected private

七、类的构造方法与可重载

类的构造方法的概念和作用

构造方法负责对象初始化工作，为对象的属性赋合适的初始值。

在用户操作对象之前，系统就已经完成了类的构造方法。

构造方法的语法规则

（1）构造方法名与类名一致
（2）没有返回类型
（3）方法实现主要为特征赋初值

构造方法的调用很特别：实例化对象（new）的时候，自动被调用

java系统保证每个类都有构造方法:如果没有指明，系统将自动为其分配“空参数”的构造方法。

class Student
{private int age;int momAge;String name;float score;Student(int newAge,String newName,float newScore)//方法名字与类名相同{                                                //构造方法在实例化对象new时会被调用，到时候再传递参数//如果不写，系统自动实现，无参无内容System.out.println("构造方法一被调用");age = newAge;name = newName;score = newScore;}//java中，方法是可重载的，即为函数名一样，参数列表不同即可，C语言是不允许的Student(String newName){System.out.println("构造方法二被调用");name = newName;}Student(String newName,float newScore){System.out.println("构造方法三被调用");name = newName;score = newScore;}Student(float newScore,String newName) //传入参数类型不同，调换顺序就成为新的构造方法{System.out.println("构造方法四被调用");name = newName;score = newScore;}/* 不能同时有两个int int类似的构造方法,否则数据混淆，IDEA不给你用Student(int newAge,int newMomAge){System.out.println("构造方法五被调用");age = newAge;momAge = newMomAge;}Student(int newMomAge,int newAge){System.out.println("构造方法五被调用");age = newAge;momAge = newMomAge;}*/
}
public class Demo1 {public static void main(String[] args) {      //使用哪种构造方法，根据传入的参数而定(不仅是靠个数判断)Student stu1 = new Student(20,"小明",100);Student stu2 = new Student("小明");Student stu3 = new Student("小明",100);Student stu4 = new Student(100,"小明");//Student stu5 = new Student(100,100);System.out.println(stu1.name + stu1.score);}
}

运行结果：

构造方法一被调用
构造方法二被调用
构造方法三被调用
构造方法四被调用
小明100.0

八、this关键字

（1）调用此方法的对象的引用
（2）可以看做是一个变量，它的值是对当前对象的引用
（3）可以处理方法中的成员变量与形参同名的问题
（4）在类的构造方法中可以调用this([参数列表])来调用该类的指定构造方法

举例子看看这4个用法：

class student
{String name;int age;void thisTest(){//第一种使用方法示例：System.out.println(this.name);//第二种使用方法示例：student stuTemp = null;//临时的对象，太像结构体指针了stuTemp = this;        //把当前对象赋给stuTemp.当前对象：如果是对象stu1，那么就是stu1对象赋给它System.out.println(stuTemp.age);//必须开辟空间（有对象）}//第三种使用方法示例:最常用的解决同名问题/*student(String name,int age){name = name;age = age;} */student(String name,int age){System.out.println("构造方法1被调用了");this.name = name;   //name传给当前对象的namethis.age = age;}//第四种使用方法示例：构造方法中又调用另一个构造方法student(String name){this("小明",21); //this构造方法只能放在第一句！！！System.out.println("构造方法2被调用了");this.name = name;}
}public class Demo1 {public static void main(String[] args) {student stu1 = new student("小明");//被指定了使用这个构造方法stu1.thisTest();//thisTest是一种方法，而stu1是调用这个方法的对象//this就是对这个对象的一种引用，引用他的特征，所以//会输出stu1对象的信息}
}

九、static关键字

（1）用来修饰类的成员 —— 修饰成员变量的称为类变量（静态变量）

（2）用来修饰成员方法 —— 称之为类方法（静态方法）

（3）用来修饰语句块 —— 称之为静态代码块

静态代码块先于构造方法之前执行，只会执行一次，用来对静态成员做初始化。当类被加载的时候静态代码块就会被加载，优先于对象的存在。

因为静态代码块的优先于对象存在，所以静态方法中不能出现this关键字：this指的是对象的引用，而static是先于对象存在的

（4）不实例化直接使用类的特征，就是依赖于对象直接对类进行访问
（5）调用的时候可以直接通过类名.成员来进行访问。

例子

class Student
{String name;int score;static int money;   //1、类变量（静态变量）Student(String name,int score){ //构造方法System.out.println("构造方法");this.name = name;this.score = score;}static {                            //3、静态代码块的格式要求System.out.println("静态代码块"); //静态代码块优先于构造方法执行money = 5;                      //并且只执行一次，因为静态变量同类一起，一开始就存在了（相对于需要创建的对象）}                                   //但构造方法每次在实例化一个对象都会执行/*static void test(){System.out.println(this.name);  //静态方法中不能出现this关键字}*/              //因为静态代码块早于对象的创建，而this就是对对象的引用//并且只能对静态成员做初始化 即moneyvoid introduce(){System.out.println("名字:"+name + "  分数："+score);}
}public class Demo1 {public static void main(String[] args) {Student stu1 = new Student("小明",98);Student stu2 = new Student("陈立臣",100);Student.money = 10; //不通过对象，直接通过类名访问类的特征。//这个静态变量优先于对象的存在（当类被加载时，money也就被加载了）//而对象实例化之后才有System.out.println("ret = "+add(1,1));//2、不通过对象，直接访问类的方法 /*如果不用static，只能new，用对象.方法的方式来访问Demo1 d1 = new Demo1();System.out.println("ret = "+d1.add(1,1));*/}static int add(int a,int b){ //2、类方法 脱离对象，直接使用方法 优先于对象的存在return a + b;}
}

运行结果（注意执行顺序！）：

静态代码块
构造方法
构造方法
ret = 2

十、方法重载：overload

同一个类中，同名不同参的方法成为重载方法（在上文类的构造方法与可重载中有大量的例子。）

多数程序设计语言（C语言）要求为每个方法（函数）提供一个独一无二的方法名，不存在方法重载的概念。而在java中，规定方法签名是解析方法的规则而不是方法名，为方法重载开创了条件。

方法重载使得在一个类中，方法名相同而参数列表不同的方法可同时存在，代表相似的行为或功能。

注意：仅有返回值不同的方法不能成为重载

System.out.print下面有很多的构造方法，也就是方法的重载

十一、包：package

标准java库是由一系列包组成，包括java.lang ,java.util,java.net等等。

java.lang

java语言的核心，它提供了java中的基础类。包括基本Object类、Class类、String类、基本类型的包装类、基本的数学类等等最基本的类。

java.net

和网络相关

java.util

集合类、时间处理模式、日期时间工具等各类常用工具包

打包的意义：

1、java的包是为了更好地规划代码，防止命名冲突和混乱。所以java出现了打包机制。

2、当把类组织起来放进一个包内时，也就给包中的成员赋予了相互访问的权限

package —— 声明包

java程序员都可以编写属于自己的java包，为了保证包名唯一性，要求程序员在自己定义包的名字前加上唯一前缀。

由于互联网上的域名名称不会重复，所以推荐采用公司在互联网上的域名的倒置作为包的唯一前缀，如 com.iotek.ch09（倒置，当然这也不是绝对的啦）

一个类可以使用同一个包中的所有类
一个类可以使用其他包中的所有公开类

怎样使用其他包中的公开类？

①在每个类的签名之前加上完整包名，例如：

java.util.Data today = new java.util.Date();

②更简洁更通用的方式：使用import语句来导包（ctrl +shift +O快捷导入）

import java.util.Date

实际地去做一个包

一个类可以使用同一个包中的所有类，不同包之间记得前面加上public

同一个工程中尽量避免出现两个完全一样的类名。容易混淆，虽然有解决的办法（导包）。

同一个类、同一个包、同一个工程。

Java面向对象（1） —— 封装相关推荐

Java 面向对象：封装详解
Java 面向对象:封装详解封装:属性私有,get/set 属性私有化提供get/set方法操作数据优点: 1.提高程序的安全性,保护数据 2.隐藏代码的实现细节 3.统一接口 4.系统可维护性 ...
Java 面向对象和封装
目录 Java 面向对象和封装面向对象思想的概述类和对象的关系什么是类什么是对象类和对象的关系局部变量和成员变量的区别 this关键字构造方法一个标准的类 Java 面向对象和封装面 ...
java封装是什么_java封装是什么？Java面向对象的封装
java封装是什么? 在面向对象程式设计方法中,封装(英语:Encapsulation)是指一种将抽象性函式接口的实现细节部份包装.隐藏起来的方法. 封装可以被认为是一个保护屏障,防止该类的代码和数据 ...
extend implements多个对象_「每天三分钟跟我学Java」之Java面向对象的封装、继承、多态...
Java是面向对象的语言,深入理解面向对象的概念,对Java的开发至关重要.本节我们着重看下面向对象的三大特性,封装.继承.多态. 一.封装封装是将类的某些信息隐藏在类内部,不允许外部程序直接访问, ...
面向小姐姐的编程——JAVA面向对象之封装（二）
文章目录封装概述什么是封装封装的好处 Java中哪些内容体现了封装? Java中的封装体 private关键字 private的基本概念特点用法扩展 this 关键字 this 的基本概念 ...
java面向对象（封装、重载、构造、继承）
在上节课中主要学习了"面向对象"的封装.方法的重载. 1.类的继承:是指在一个现有类的基础上去构建一个新的类,构建出来的新类被称作子类,现有类被称作父类或者基类,子类会自动拥有父类 ...
java面向对象之封装,java面向对象之封装-Go语言中文社区
一直感觉自己对面向对象编程理解的不是很深刻所以总结下这篇文章留作笔记共勉在面向对象程式设计方法中,封装(英语:Encapsulation)是指一种将抽象性函式接口的实现细节部份包装.隐藏起来的方 ...
java封装原则_跟我学java编程—理解Java面向对象的封装原则
前面一节内容讲到了抽象与对象,抽象是把同类事物的共同特征抽取出来归纳为类,类的具体实例为对象.例如:把具有汁液多.糖分多.含有挥发性芳香物质.可以生食等特征的事物归纳为水果类,苹果.葡萄.生梨则为水果 ...
Java面向对象和封装
一.面向对象思想的概述面向谁就是更加关注谁在程序中分为面向过程和面向对象 package test;import java.util.Arrays;/* 面向过程,当需要实现一个功能的时候,每一个 ...
面向小姐姐的编程——JAVA面向对象之封装（一）
文章目录面向对象思想概述什么是面向对象? 类与对象现实中如何描述一个事物? Java中如何描述一个事物? 类的概念: 抽象什么是对象? 类和对象的关系类的定义和使用创建一个对象并使用创建 ...

Java面向对象（1） —— 封装

目录