1、封装是什么
将东西包在一起。然后以新的完整形式呈现出来
将方法和字段一起包装到一个单元中，单元以类的形式实现
信息隐藏，隐藏对象的实现细节，不让外部直接访问到
将数据和方法包装进类中，加上具体实现的隐藏（访问修饰符），共同被称作为封装，其结果是一个同时带有特征和行为的数据类型
2、类的封装和使用示例
class student {
int age;
String name;
double score;
void introduce(){ //方法 = 函数
//不需要传参，因为Java面向对象，可以直接访问它里面的成员变量
System.out.println("name=" +name + "age="+age + "score="+score);
}
void testFunc(){
System.out.println("testFunc");
}
}
public class Test {
public static void main(String[] args) {
student stu1 = new student(); //实例化一个对象，类=模板，只有属性和方法，类不能直接使用需要先实例化一个对象
//struct student *p;
//p = malloc(sizeof(struct student));
stu1.age = 18;
stu1.name = "zheng";
stu1.score = 100;
stu1.introduce();//不需要传参，可以访问到同组变量
}
}
3、访问修饰符
private：该类或非该类均可以访问
protected：只有该类可以访问
public：该类及其子类的成员可以访问，同一个包中的类也可以访问
默认：同一个包中的类可以访问
class student {
double score;
private int data;
void datefunc(int num)
{
data = num;//同一个类中可以访问
}
}
public class Test {
public static void main(String[] args) {
student stu1 = new student();
stu1.data= 1;//不能访问，private 属性
stu1.score = 100;//可以访问，默认属性
stu1.datefunc(100);//private 属性的变量可以通过函数去间接访问并修改
}
}
4、构造方法
UML类图
Unified Modeling Language（UML）又称统一建模语言或标准建模语言
类的命名尽量应用领域中的术语
应明确、无企业，以利于相互交流和理解
类的属性、操作中的可见性使用+、#、-，分别表示public、protected、private
构造方法
类的构造方法的概念和作用
构造方法复制对象初始化工作，为对象的属性赋合适的初始值
创建对象时，其类的构造方法确保在用户操作对象之前，系统保证初始化的进行
构造方法的语法规则
构造方法名与类名一致
没有返回类型
方法实现主要为字段赋初值
构造方法的调用：
构造方法的调用很特别：new操作符（实例化对象的时候，自动被调用）
代码实例：
class student {
int age;
String name;
double score;
student(int newage, String newname, double newscore)
{
System.out.println("构造方法被调用");
age = newage;
name = newname;
score = newscore;
}
}
public class Test {
public static void main(String[] args) {
student stu1 = new student(18, "zheng", 99.8);
//new的时候自动调用构造方法
}
}
效果：
可以看到我们在主函数并没有调用什么东西，构造方法在new的时候自动调用
Java语言中，方法是可重载的：函数名一样，参数列表不同，在C语言中不行
class student {
int age;
String name;
double score;
student()
{
System.out.println("构造方法一被调用");
}
student(int newage, String newname)
{
System.out.println("构造方法二被调用");
age = newage;
name = newname;
}
student(int newage, String newname, double newscore)
{
System.out.println("构造方法三被调用");
age = newage;
name = newname;
score = newscore;
}
}
public class Test {
public static void main(String[] args) {
student stu1 = new student(18, "zheng", 99.8);
student stu2 = new student();
student stu3 = new student(18, "zheng");
}
}
5、this关键字
特点：
1.在类的方法中，使用this关键字代表的是调用此方法的对象的引用
2.this可以看做是一个变量，它的值是当前对象的引用
3.使用this可以处理方法中的成员变量和形参同名的问题
4.当在方法内需要用到调用该方法的对象时，就可以用this
5.在类的构造方法中可以调用this（【参数列表】）来调用该类的指定构造方法
在类的方法中，使用this关键字代表的是调用此方法的对象的引用：
class student {
int age;
String name;
double score;
void thistest()
{
System.out.println(this.name);
}
student(int newage, String newname, double newscore)
{
System.out.println("构造方法被调用");
age = newage;
name = newname;
score = newscore;
}
}
public class Test {
public static void main(String[] args) {
student stu1 = new student(18, "zheng", 99.8);
stu1.thistest();
}
}
输出了调用此方法的对象的name：
this可以看做是一个变量，它的值是当前对象的引用：
void thistest()
{
student stutmp = null;
stutmp = this;
System.out.println(stutmp.name);
System.out.println(this.name);
}
使用this可以处理方法中的成员变量和形参同名的问题：
student(int age, String name, double score)
{
System.out.println("构造方法被调用");
this.age = age;
this.name = name;
this.score = score;
}
当在方法内需要用到调用该方法的对象时，就可以用this：
和第一个差不多
在类的构造方法中可以调用this（【参数列表】）来调用该类的指定构造方法：
在一个构造方法中调用另一个构造方法
调用构造方法的语句必须是放在第一条
class student {
int age;
String name;
double score;
student(int newage, String newname)
{
System.out.println("构造方法二被调用");
age = newage;
name = newname;
}
student(int newage, String newname, double newscore)
{
this(18,"zheng"); //调用了满足两个参数的构造方法
System.out.println("构造方法三被调用");
age = newage;
name = newname;
score = newscore;
}
}
public class Test {
public static void main(String[] args) {
student stu1 = new student(18, "zheng", 99.8);
}
}
6、static关键字
特点：
1.用来修饰类的成员–修饰成员变量的称为类变量（静态变量）
2.修饰成员方法称之为类方法（静态方法）
3.当类被加载的时候就会被加载，优先于对象的存在
4.用来修饰语句块–称之为静态代码块，先于构造方法前执行，只会执行一次，用来对静态成员做初始化
5.调用的时候可以直接通过类名.成员来进行访问
类里面的方法或参数在其他类调用，如果不想实例化（new）的话，就要在前加static
注意事项：
1.静态方法中只能访问外部的静态成员
2.静态方法中不能出现this关键字（因为this是对对象操作，static优先于对象存在）
7、方法重载
多数程序设计语言要求为每个方法（函数）提供一个独一无二的方法名，不存在方法重载的概念
在Java中，规定方法签名是解析方法的规则而不是方法名，为方法重载开创了条件
方法重载使得在一个类中，方法名相同而参数列表不同的方法可同时存在，代表相似的行为或功能
重载overload概念：同一个类中，同名不同参的方法称为重载方法
注意：仅有返回值不同的方法不能称为重载
方法重载并不陌生，我们System.out.println(）就是方法的重载
8、包
打包的意义：
标准Java库是由一系列包组成，包括Java.lang 、Java.util 、Java.net等
标准Java包就是层次型包结构，就如同硬盘上的子目录一样，我们可以使用嵌套层次结构来组织包
Java的包是为了更好地规范代码，防止命名冲突和混乱。所以Java出现了打包机制
当把类组织起来放进一个包内只时，也就给包中的成员赋予了相互访问的权限，您就拥有了该包内的程序代码
包访问权限把类聚集在一个包中这一做法提供了意义和理由
package–声明包
Java程序猿都可以编写属于直接的Java包，为了保证包名唯一性，要求程序猿在自己定义包的名字前面加上唯一前缀
由于互联网上的域名不会重复，所以推荐采用公司在互联网上的域名的倒置作为包的唯一前缀
一个类可以使用同一个包中所有的类
一个类可以使用其他包中的所有公开类
怎么使用其他包中的公开类：
1.在每个类签名加上完整包名，例如 java.util.Data today = new java.util.Date();
2.更简介更通用的方式：使用Import语句来导包（eclipse ctrl+shift+o）
import java.util.Date
......
Date today = new Date();
3.可以Import特定类，也可以导入整个包。通过在源代码文件的顶部（在打包语句后）使用Import语句来实现import java.util.*;
示例
我们在建立一个class的时候添加一个自己的包：
TestNew.java:
package com.zheng.learn;
public class TestNew {
int age;
void printfdata(){
System.out.println("age="+age);
}
}
Test.java:
package com.zheng.learn;
public class Test {
public static void main(String[] args) {
TestNew dm = new TestNew();
dm.age = 10;
dm.printfdata();
}
}
运行结果：（运行Test.java）
TestNew.java:
package com.zheng.use;
public class TestNew {
public String name; //默认权限不能访问不同包的类，public才行
public void printfinfo(){ //默认权限不能访问不同包的类，public才行
System.out.println("name="+name);
}
}
Test.java:
package com.zheng.learn;
public class Test {
public static void main(String[] args) {
TestNew dm = new TestNew();
dm.age = 10;
dm.printfdata();
com.zheng.use.TestNew dm2 = new com.zheng.use.TestNew();
dm2.name = "zheng";
dm2.printfinfo();
}
}
运行结果：
4974
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
