package cn.itcast.introspector;
import java.io.BufferedReader;
/*
需求：编写一个工厂方法根据配置文件的内容，工厂方法返回对应的对象，并且把对象要有对应的属性值。
*/
import java.io.FileReader;
import https://www.doczj.com/doc/2811904948.html,ng.reflect.Constructor;
import https://www.doczj.com/doc/2811904948.html,ng.reflect.Field;
/*
以后我们开发框架的时候，我们是经常需要把一些数据封装到对象中的。
*/
public class Demo1 {
public static void main(String[] args) throws Exception {
Person p = (Person) getInstance();
System.out.println(p);
}
//根据配置文件的内容生产对象的对象并且要把对象的属性值封装到对象中。
public static Object getInstance() throws Exception{
BufferedReader bufferedReader = new BufferedReader(new FileReader("obj.txt"));
String className = bufferedReader.readLine(); //读取配置文件获取到完整的类名。
Class clazz = Class.forName(className);
//通过class对象获取到无参的构造方法
Constructor constructor = clazz.getConstructor(null);
//创建对象
Object o = constructor.newInstance(null);
//读取属性值
String line = null;
while((line = bufferedReader.readLine())!=null){
String[] datas = line.split("=");
//通过属性名获取到对应的Field对象。
Field field = clazz.getDeclaredField(datas[0]);
if(field.getType()==int.class){
field.set(o, Integer.parseInt(datas[1]));
}else{
field.set(o, datas[1]);
}
}
return o;
}
}
反射
package cn.itcast.introspector;
import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import https://www.doczj.com/doc/2811904948.html,ng.reflect.Method;
import org.junit.Test;
/*
内省--->一个变态的反射.
内省主要解决的问题：把对象的属性数据封装到对象中。
*/
public class Demo2 {
@Test
public void getAllProperty() throws IntrospectionException{
//Introspector 内省类
BeanInfo beanInfo = Introspector.getBeanInfo(Person.class);
//通过BeanInfo获取所有的属性描述其
PropertyDescriptor[] descriptors = beanInfo.getPropertyDescriptors(); //获取一个类中的所有属性描述器
for(PropertyDescriptor p : descriptors){
System.out.println(p.getReadMethod()); //get方法
}
}
@Test
public void testProperty() throws Exception{
Person p = new Person();
//属性描述器
PropertyDescriptor descriptor = new PropertyDescriptor("id", Person.class);
//获取属性对应的get或者是set方法设置或者获取属性了。
Method m = descriptor.getWriteMethod(); //获取属性的set方法。
//执行该方法设置属性值
m.invoke(p,110);
Method readMethod = descriptor.getReadMethod(); //是获取属性的get方法
System.out.println(readMethod.invoke(p, null));
}
}
BeanUtil
package cn.itcast.introspector;
import https://www.doczj.com/doc/2811904948.html,ng.reflect.InvocationTargetException;
import java.text.SimpleDateFormat;
import java.util.Date;
import javax.xml.crypto.Data;
import https://www.doczj.com/doc/2811904948.html,mons.beanutils.BeanUtils;
import https://www.doczj.com/doc/2811904948.html,mons.beanutils.ConvertUtils;
import https://www.doczj.com/doc/2811904948.html,mons.beanutils.Converter;
/*
BeanUtils：
BeanUtils主要解决的问题：把对象的属性数据封装到对象中。
BeanUtils的好处：
1. BeanUtils设置属性值的时候，如果属性是基本数据类型，BeanUtils会自动帮我转换数据类型。
2. BeanUtils设置属性值的时候底层也是依赖于get或者Set方法设置以及获取属性值的。
3. BeanUtils设置属性值,如果设置的属性是其他的引用类型数据，那么这时候必须要注册一个类型转换器。
BeanUtilss使用的步骤：
1. 导包commons-logging.jar 、 commons-beanutils-1.8.0.jar
*/
public class Demo3 {
public static void main(String[] args) throws Exception {
//从文件中读取到的数据都是字符串的数据，或者是表单提交的数据获取到的时候也是字符串的数据。
String id ="110";
String name="陈其";
String salary = "1000.0";
String birthday = "2013-12-10";
//注册一个类型转换器
ConvertUtils.register(new Converter() {
@Override
public Object convert(Class type, Object value) { // type : 目前所遇到的数据类型。 value :目前参数的值。
Date date = null;
try{
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
date = dateFormat.parse((String)value);
}catch(Exception e){
e.printStackTrace();
}
return date;
}
}, Date.class);
Emp e = new Emp();
BeanUtils.setProperty(e, "id", id);
BeanUtils.setProperty(e, "name",name);
BeanUtils.setProperty(e, "salary",salary);
BeanUtils.setProperty(e, "birthday",birthday);
System.out.println(e);
}
}
输出
编号：110 姓名：陈其薪水：1000.0 生日：Tue Dec 10 00:00:00 CST 2013
EMP.java
package cn.itcast.introspector;
import java.util.Date;
public class Emp {
private int id;
private String name;
private double salary;
private Date birthday;
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
https://www.doczj.com/doc/2811904948.html, = name;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
public Emp(int id, String name, double salary) { super();
this.id = id;
https://www.doczj.com/doc/2811904948.html, = name;
this.salary = salary;
}
public Emp(){}
@Override
public String toString() {
return"编号："+this.id+" 姓名："+ https://www.doczj.com/doc/2811904948.html,+ " 薪水：
"+ this.salary+" 生日："+ birthday;
}
}
Person.java
package cn.itcast.introspector;
//实体类---javaBean
public class Person {
private int id;
private String name;
public Person(int id, String name) {
super();
this.id = id;
https://www.doczj.com/doc/2811904948.html, = name;
}
public Person(){}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
https://www.doczj.com/doc/2811904948.html, = name;
}
@Override
public String toString() {
return"编号："+ this.id+" 姓名："+ https://www.doczj.com/doc/2811904948.html,;
}
}
java分页类封装 分页类的主要有3个基本字段：当前页（页码）、分页大小(每页显示的数据大小)、数据总数目。 当前页：currentPage 分页大小：pageSize 数据总数目: recordTotalCount 注意： “/”:代表求商，如7/3=2 “%”:代表求余，如7%3=1 由基本字段派生出来的字段：是否有上一页previous、是否有下一页next、总页数totalPage 是否有上一页是由当前页决定，看当前页是否大于1 是否有下一页是由总页数决定，看当前页是否小于总页数 总页数是由数据总数目和分页大小决定。 例如：如果数据有92条，你要每页显示10条，92÷10=9...2 ,多出来的2条数据，也算1页，总页数就是9+1=10页。 怎么处理余数，看以下公式 公式1 总页数=[数据总数目]/[分页大小]+(余数>0,则+1，余数=0,则+0)。 如92÷10=9...2 ，9+1=10 公式2 总页数=[数据总数目]÷[分页大小]的向上取整。 如92÷10=9.2 ,向上取整为10 公式3 总页数=([数据总数目]+([分页大小]-1))/[分页大小] 不明白为什么[分页大小]要减去1? (92+(10-1))/10=10 => 90/10+ (2+(10-1))/10= > 9+1 它是这样处理余数的 不管数据总数目是多少，余数的范围是0<=余数<=被除数-1，所以，余数的范围是0<=余数<=分页大小-1 (余数值+(余数范围的最大值))/分页大小=> (2+(10-1))/10=1 也就是(余数值+(分页大小-1))/分页大小的结果是等价于公式1中的(余数>0,则+1，余数=0,则+0) 公式3不方便开发人员理解，但是就是有许多人用，本人不推荐用，没必要弄复杂，自己不明白，其他人也是一脸闷逼。最好就用公式一或公式二，简单明了迅速准确。
Java面向对象 面向对象 在Java中，高手们的概念就是万物皆对象。 面向对象的概念： 面向对象：是基于面向过程的一种思想。 面向过程：强调的是功能行为。 面向对象：将功能封装进对象，强调具备了功能的对象。面向对象是基于面向过程的。 面向对象和面向过程： 图例：
面向对象特点： 1，面向对象就是一种常见的思想。符合人们的思考习惯。 2，面向对象的出现，将复杂的问题简单化。 3，面向对象的出现，让曾经在过程中的执行者，变成了对象中的指挥者。面试题：你怎么理解面向对象的？ 1，它符合现在人们思考的一种习惯 2，它让我们复杂的事情简单化 3，让我们从曾经的执行都变为现在的指挥者 其实面试官你本身就在用面向对象的方式思考问题
因为以面试官您的能力而言，来了一个软件项目的话，您从需求分析到设计到开发到测试，都能完成，但是这样特别耗时间，所以您为了提高效率，您就需要 去找一些具备专业编程经验的人来完成这些项目，我正好就是那个具备专业编程经验的对象，您只要指挥我这个对象做事情就可以了，我会给您一个非常满意的 结果，至于过程您不用管。所以面试官您就在用面向对象的方式思考问题，来提高公司的效率，而我就是具备专业编程经验的人。 面向对象有三个特征：封装，继承，多态 以后的开发过程：其实就是找对象用。没有对象，就创建一个对象。 找对象，建立对象，使用对象，并维护对象的关系。 类和对象的关系： 类：就是对现实生活中事物的描述。 对象：就是这类事物，实实在在存在的个体。 想要描述：提取对象中共性内容。对具体的抽象。 映射到Java中描述就是class定义的类。 具体对象就是对应Java在堆内存中用new建立实体。 例子： 需求：描述小汽车。描述事物其实就是在描述事情的属性和行为。 分析： 1，属性：轮胎数。颜色。 2，行为：运行。 定义类其实就是在定义类中的成员。 成员：成员变量<-->属性，成员函数<-->行为。 属性对应是类中变量，行为对应的类中函数或方法。 其实定义类，就是在描述事物，就是在定义属性和方法，属性和行为共同成为类中的成员（成员变量和成员方法）。
计算机工程系实验报告 课程名称：Java面向对象程序设计 班级：姓名：学号： 一、实验目的: 掌握使用类来封装对象的属性和功能。 二、实验要求: 1、编写一个Java应用程序，该程序中有3个类：Trangle，Lader和Circle，分别用来刻画三角形、梯形和圆形，具体要求如下： 1）Trangle类具有三个边长、周长和面积属性，具有返回周长、面积以及修改三个边的功能。另外还有一个boolean类型的属性，该属性用来判断三个数能否构成一个三角形。 2）Lader类具有上底、下底、高、面积属性，具有返回面积的功能。 3）Circle类具有半径、周长和面积属性，具有返回周长和面积的功能。 4）按程序模板的要求，将代码1-代码24替换为Java程序代码 5）给Trangle类增加三个方法，分别用来返回三个边：sideA,sideB,sideC。 6）让AreaAndLength类中的circle对象调用方法修改半径，然后输出修改后的半径以及修改半径后的圆的面积和周长。 2、编写一个类Person，可描述姓名、性别、年龄，可获取姓名、性别、年龄。该类含两个构造方法，一个无参数，一个带三个参数。编写主类，在主方法中分别用两个构造方法创建两个Person类的对象，分别输出这两个对象的姓名、性别、年龄。 三、程序代码: 1、程序模板 class Trangle { double sideA,sideB,sideC,area,length; boolean boo; public Trangle(double a,double b,double c) { sideA=a; sideB=b; sideC=c; //a,b,c分别赋值给sideA,sideB,sideC if(sideA+sideB>sideC&&sideB+sideC>sideA&&sideA+sideC>sideB) //a,b,c构成三角形的条件 { boo=true; //给boo赋值 } else {
package cn.itcast.introspector; import java.io.BufferedReader; /* 需求：编写一个工厂方法根据配置文件的内容，工厂方法返回对应的对象，并且把对象要有对应的属性值。 */ import java.io.FileReader; import https://www.doczj.com/doc/2811904948.html,ng.reflect.Constructor; import https://www.doczj.com/doc/2811904948.html,ng.reflect.Field; /* 以后我们开发框架的时候，我们是经常需要把一些数据封装到对象中的。 */ public class Demo1 { public static void main(String[] args) throws Exception { Person p = (Person) getInstance(); System.out.println(p); } //根据配置文件的内容生产对象的对象并且要把对象的属性值封装到对象中。
public static Object getInstance() throws Exception{ BufferedReader bufferedReader = new BufferedReader(new FileReader("obj.txt")); String className = bufferedReader.readLine(); //读取配置文件获取到完整的类名。 Class clazz = Class.forName(className); //通过class对象获取到无参的构造方法 Constructor constructor = clazz.getConstructor(null); //创建对象 Object o = constructor.newInstance(null); //读取属性值 String line = null; while((line = bufferedReader.readLine())!=null){ String[] datas = line.split("="); //通过属性名获取到对应的Field对象。 Field field = clazz.getDeclaredField(datas[0]); if(field.getType()==int.class){ field.set(o, Integer.parseInt(datas[1])); }else{ field.set(o, datas[1]); } } return o; } }
Java中八种基本数据类型和八种封装数据类型 初使值的求解过程及比较 作者：Zealjiang 1.八种基本数据类型 创建名为MemberTestBasic的java文件，其内容如下：public class MemberTestBasic { /** 八种基本类型 int, short, float ,double, long, boolean, byte, char */ int i; short s; float f; double d; long l; boolean bo; byte by; char c; public static void main(String[] args) { //创建对象m
MemberTestBasic m=new MemberTestBasic(); m.printMember(); } //为对象m创建一个printMember方法 public void printMember() { System.out.print("int->"+i+"\n"); System.out.print("short->"+s+"\n"); System.out.print("float->"+f+"\n"); System.out.print("double->"+d+"\n"); System.out.print("long->"+l+"\n"); System.out.print("boolean->"+bo+"\n"); System.out.print("byte->"+by+"\n"); System.out.print("char->"+c+"\n"); } } 运行结果如下：
java基本数据类型与其封装类 1 Boolean VS boolean public final class Boolean extends [url=file:///G:/html_zh_CN/html/zh_CN/api/java/lang/Object.html]Object[/url]implements [url=file:///G:/html_zh_CN/html/zh_CN/api/java/io/Serializable.html]Serializable[/url], [url=file:///G:/html_zh_CN/html/zh_CN/api/java/lang/Comparable.html]Comparable[/url]<[url=fil e:///G:/html_zh_CN/html/zh_CN/api/java/lang/Boolean.html]Boolean[/url]> Boolean 类将基本类型为boolean的值包装在一个对象中。一个Boolean类型的对象只包含一个类型为boolean的字段。 此外，此类还为boolean和String的相互转换提供了许多方法，并提供了处理boolean时非常有用的其他一些常量和方法。 2 Byte VS byte public final class Byte extends [url=file:///G:/html_zh_CN/html/zh_CN/api/java/lang/Number.html]Number[/url]implements [url=file:///G:/html_zh_CN/html/zh_CN/api/java/lang/Comparable.html]Comparable[/url]<[url=fil e:///G:/html_zh_CN/html/zh_CN/api/java/lang/Byte.html]Byte[/url]> Byte类将基本类型byte的值包装在一个对象中。一个Byte类型的对象只包含一个类型为byte的字段。 此外，该类还为byte和String的相互转换提供了几种方法，并提供了处理byte时非常有用的其他一些常量和方法。 3 Character VS char public final class Character extends [url=file:///G:/html_zh_CN/html/zh_CN/api/java/lang/Object.html]Object[/url]implements [url=file:///G:/html_zh_CN/html/zh_CN/api/java/io/Serializable.html]Serializable[/url], [url=file:///G:/html_zh_CN/html/zh_CN/api/java/lang/Comparable.html]Comparable[/url]<[url=fil e:///G:/html_zh_CN/html/zh_CN/api/java/lang/Character.html]Character[/url]> Character类在对象中包装一个基本类型char的值。Character类型的对象包含类型为char的单个字段。 此外，该类提供了几种方法，以确定字符的类别（小写字母，数字，等等），并将字符从大写转换成小写，反之亦然。 4 Double VS double public final class Double extends [url=file:///G:/html_zh_CN/html/zh_CN/api/java/lang/Number.html]Number[/url]implements [url=file:///G:/html_zh_CN/html/zh_CN/api/java/lang/Comparable.html]Comparable[/url]<[url=fil e:///G:/html_zh_CN/html/zh_CN/api/java/lang/Double.html]Double[/url]> Double类在对象中包装了一个基本类型double的值。每个Double类型的对象都包含一个double类型的字段。 此外，该类还提供了多个方法，可以将double转换为String，将String转换为double，还提供了其他一些处理double时有用的常量和方法。
Java语言基本数据类型、转换及其封装Java语言基本数据类型、转换及其封装 1. 逻辑类型 ·常量 true，false。 ·变量的定义 使用关键字boolean来定义逻辑变量： boolean x; boolean tom_12; 也可以一次定义几个： boolean x,tom,jiafei,漂亮 x，tom，jiafei，漂亮都是变量的名字。定义时也可以赋给初值： boolean x=true,tom=false,漂亮=true,jiafei 2.整数类型 ·常量123，6000（十进制），077（八进制），0x3ABC（十六进制）。 ·整型变量的定义分为4种： 1.int 型 使用关键字int来定义int型整形变量 int x int tom_12 也可以定义几个： int x,tom,jiafei,漂亮 x，tom，jiafei，漂亮都是名字。定义时也可以赋给初值： int x=12,tom=-1230,漂亮=9898,jiafei 对于int型变量，分配给4个字节byte,一个字节由8位（bit）组成，4个字节占32位（bit）。bit 有两状态，分别用来表示0，1。这样计算机就可以使用2进制数来存储信息了。内存是一种特殊的电子元件，如果把内存条放大到摩天大
楼那么大，那么它的基本单位——字节，就好比是大楼的房间，每个房间的结构都是完全相同的，一个字节由8个能显示两种状态的bit组成，就好比每个房间里有8个灯泡，每个灯泡有两种状态——亮灯灭灯。 对于 int x=7; 内存存储状态如下： 00000000 00000000 00000000 00000111 最高位：左边的第一位，是符号位，用来区分正数或负数，正数使用原码表示，最高位是0，负数用补码表示，最高位是1。例如： int x=-8; 内存的存储状态如下： 11111111 11111111 11111111 11111000 要得到-8的补码，首先得到7的原码，然后将7的原码中的0变成1，1变成0，就是-8的补码。 因此，int型变量的取值范围是-2^31~2^31-1。 2. byte型 使用关键字byte来定义byte型整型变量 byte x ; byte tom_12; 也可以一次定义几个： byte x,tom,jiafei,漂亮 x，tom，jiafei，漂亮都是名字。定义时也可以赋给初值： byte x=-12,tom=28,漂亮=98,jiafei 注：对于byte型变量，内存分配给1个字节，占8位，因此byte型变量的取值范围是： -2^7~2^7-1。
第一章 抽象和封装 1.为什么使用面向对象 面向对象就是采用“现实模拟”的方法设计和开发程序。 面向对象实现了虚拟世界和现实世界的一致性，符合人们的思维习惯，使得客户和软件设计开发人员之间，软件设计开发人员内部交流更加顺畅，同时还带来了代码重用性高、可靠性高等优点，大大提高了软件尤其是大型软件的设计和开发效率 2.使用面向对象进行设计 面向对象设计的过程就是抽象的过程。 根据业务相关的属性和行为，忽略不必要的属性和行为，由现实世界中“对象”抽象出软件开发中的对象 第一步：发现类 第二步：发现类的属性 第三步：发现类的方法 类的基本结构，其主要由属性和行为组成，称为类的成员变量（或者成员属性）和成员方法，统称为类的成员（除此之外类的成员还包括构造方法，代码块等） 对象的创建： 通过够造方法来创建对象。 通过对象名.属性名的方式调用属性 通过对象名.方法名的方式调用方法 Static 可以用来修饰属性、方法和代码快。Static的变量属于这个类所有，即由这个 类创建的所有对象共同用一个 Static 变量。通常把Static修饰的属性和方法称为类 属性（类变量）、类方法。不使用Static修饰的属性和方法，属于单个对象，通常称为 实例属性（实例变量），实例方法。 类属性、类方法可以通过类名和对象名访问，实例属性、实例方法只能通过对象名访问。Final 可以用来修饰属性、方法和类。用final修饰的变量称为常量，其值固定不变。 构造方法的名字和类名相同，没有返回值类型。构造方法的作用主要就是在创建对象时 执行一些初始化操作，如给成员属性赋初值。
在没有给类提供任何构造方法时，系统会提供一个无参的方法体为空的默认构造方法。一旦提供了自定义构造方法，系统将不会再提供这个默认的构造方法，如果要使用，必须手动添加。 如果一个类中包含了两个或两个以上方法，他们的方法名相同，方法参数个数或参数类型不同，则称该方法被重载了，这个过程称为方法重载，成员方法和构造方法都可以进行重载。 常见错误： 在类中可以定义Static变量，在方法里是否可以定义Static变量？ 结论：在方法里不可以定义Static变量，也就是说类变量不能是局部变量。 给构造函数加上返回值类型会出现什么情况？ 结论：构造方法没有返回值类型，如果有，就不是构造方法，而是和构造方法同名的成员变量。 4．用封装优化类 封装：将类的状态信息隐藏在类内不能，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。 封装的具体步骤：修改属性的可见性来限制对属性的访问；为每个属性创建一对赋值方法（setter）和取值方法（getter），用于对这些属性的存取；在赋值方法中加入对属性的存取控制语句。 封装的好处主要有：隐藏类的实现细节；让使用者只能通过程序员规定的方法来访问数据；可以方便地加入存取控制语句，限制不合理操作。 封装时会用到多个权限控制符来修饰成员变量和方法，区别如下。 Private:成员变量和方法只能在类内被访问，具有类可见性 默认：成员变量和方法只能被同一个包里的类访问，具有包可见性。 Protected：可以被同一个包中的类访问，被同一个项目中不同包中的子类访问Public：可以被同一个项目中所有的类访问，具有项目可见性，这是最大的访问权限 第二章 继承 2.1 继承基础 1.在java中，继承通过extends关键字来实现， 2.父类又叫基类和超类。
今天在项目中需要用到使用java代码，拼成json的list对象，小研究一下，写出来分享给大家： 方法一： if (CollectionUtil.isNotEmpty(userModelList)) { List
JSONObject jsonobj = JSONObject.fromObject(oo); jsonobj.putAll(status); o.put("jsonp", jsonobj); System.out.println(o.toString()); return o.toString(); } //////////结果类似这样： {jsonp={"users":[{"id":"1","name":"客服NO1","image":null},{"id":"asfdafasd","name":"sdaf","image":"sadfas "},{"id":"asfdafasd","name":"sdaf","image":"sadfas"}],"status":"ok"} } 你也可以继续嵌套构造多级 方法2 直接使用string拼接 先new一个list，下边是部分代码
面向对象编程基本知识练习 一、判断题 1.不需要定义类，就能创建对象。（） 2.构造方法用于给类的private 实例变量赋值。（） 3.对象一经声明就可以立即使用。（） 4.在定义变量和方法时，必须清楚地在其面前标上访问权限修饰符。（） 5.Java 程序中的参数传递都是把参数值传递给方法定义中的参数。（） 6.在类定义中，成员访问权限修饰符不能多次出现。（） 7.new 操作符动态地为对象按其指定的类型分配内存，并返回该类型的一个引用。（） 8.类的方法通常设为public ，而类的实例变量一般也设为public 。（） 9.构造方法在创建对象时被调用。（） 10.通过点运算符与类对象的引用相连，可以访问此类的成员。（） 11.声明为protected 的类成员只能被此类中的方法访问。（） 12.同一个类的对象使用不同的内存段，但静态成员共享相同的内存空间。（） 13.类的成员变量可以放在类体的任意位置。（） 14.声明为protected 的类成员可以被此类作用域中的任何对象访问。（） 15.没有返回值的方法可以用void 来表示，也可以不加。（） 二、选择题 1.下面对对象概念描述错误的是：（） A 操作是对象的动态属性 B 任何对象都必须有继承性 C 对象间的通讯靠消息传递 D 对象是属性和方法的封装体 2．编译并运行下面的程序，运行结果为：（） public class A { public static void main（String[] args） { A a=new A（）； a.method（8）； } void method（int i） { System.out.println（“int：“+i）；
竭诚为您提供优质文档/双击可除 java实现协议封装 篇一：浅谈java封装 封装 封装就是指利用抽象数据类型将数据和基于数据的操作封装在一起，使其构成一个不可分割的独立实体，数据被保护在抽象数据类型的内部，尽可能地隐藏内部的细节，只保留一些对外接口使之与外部发生联系。也就是说用户是无需知道对象内部的细节（当然也无从知道），但可以通过该对象对外的提供的接口来访问该对象。 使用封装有三大好处： 1、良好的封装能够减少耦合。 2、类内部的结构可以自由修改。 3、可以对成员进行更精确的控制。 4、隐藏信息，实现细节。 1.publicclasshusband{ 2. 3./* 4.*对属性的封装
5.*一个人的姓名、性别、年龄、妻子都是这个人的私有属性 6.*/ 7.privatestringname; 8.privatestringsex; 9.privateintage; 10.privatestringwife; 11. 12./* 13.*setter()、getter()是该对象对外开发的接口 14.*/ 15.publicstringgetname(){ 16.returnname; 17.} 18. 19.publicvoidsetname(stringname){ https://www.doczj.com/doc/2811904948.html,=name; 21.} 22. 23.publicstringgetsex(){ 24.returnsex; 25.}
26. 27.publicvoidsetsex(stringsex){ 28.this.sex=sex; 29.} 30. 31.publicintgetage(){ 32.returnage; 33.} 34. 35.publicvoidsetage(intage){ 36.this.age=age; 37.} 38. 39.publicvoidsetwife(stringwife){ 40.this.wife=wife; 41.} 42.} 从上面两个实例我们可以看出： 封装把一个对象的属性私有化，同时提供一些可以被外界访问的属性的方法，如果不想被外界方法，我们大可不必提供方法给外界访问。但是如果一个类没有提供给外界访问的方法，那么这个类也没有什么意义了。
实验四、类的封装 一、实验目的 1. 掌握类的声明和定义； 2. 理解有静态成员和非静态成员变量的区别； 3. 理解基本参数和引用参数的区别； 4. 掌握类构造方法的编写； 5. 实现类的方法； 6. 掌握创建类实例的方法； 7. 学会定义和使用具有重载方法的继承类； 8. 掌握方法的重新定义。 二、实验内容 1．以下程序运行的结果是。 运行结果初始时 x=10, y=10 方法调用中 x=100, y=100 方法调用后 x=100, y=100 public class sy4_1 { public static void main(String[] args) { Power p=new Power(); p.ff2(10,10); System.out.println("方法调用后x="+p.x+", y="+p.y); } } class Power{ int x=10, y=10; void ff2(int passX, int passY){ System.out.println("初始时x="+x+", y="+y); x=passX*passX; y=passY*passY; System.out.println("方法调用中x="+x+", y="+y); } } 2.建立日期类及日期对象的简单引用，程序结构如下，写出完整代码。public class MyDate0 //声明日期类 { int year, month, day; //成员变量 void set(int y, int m, int d) { ... } //成员方法，设置日期 public String toString() { … } //成员方法返回中文日期 public static void main(String args[]) // 主方法 { ….//创建日期对象d1 ….//显示d1 的中文日期 ….//设置d1 的成员变量为今天日期
一：包装类（封装类）： 1：Java中的8中简单类型：（不是对象，与一切皆是对象相悖） byte、short、int、long char、 float、double boolean 2：所以针对以上8种简单类型构造了封装类。 对应的封装类： Byte、Short、Integer、Long Charater、 Float、Double Boolean 3:jdk1.5之后： 自动装箱:把简单数据类型变成相对应的封装类。 自动拆箱：把封装类变成相对应的简单数据类型。 Int i=10; Integer m=new Integer（10）； Int i=10； Integer m=i；（自动装箱） Int j=m；（自动拆箱） double pi=3.14d; Double d=pi;// （自动装箱）:new Double(3.14) double d1=d;// （自动拆箱） 4：封装类提供类实用的数据类型之间的转换。提供了众多对数字以及字符串操作的方法。 封装类都是final类 封装类的对象是不变的，和string类似。 覆盖（重写）了Object里面的equals和toString方法。 例如：string a=“hello”； a=“world”； 在内存空间里面给a重新开辟了一块空间用来保存“world”，“hello”这块空间没有被改写。 常用的：
字符串转换为数字 String age=”19”; Int intAge=Integer.parseInt(age);// parseInt:把字符串转换为整形 String salary=“5678.9”； double dsalary=Double.ParseDouble（salary）； 数字转换为字符串 int intage=19; String age=intage+””; String age=Integer.toString(intage); 十进制数字转化为十六进制字符： String age = Integer.toHexString(intage); 十进制数字转化为二进制字符： String age = Integer.toBinaryString(intage);
先来个例子看看； public class Man { //对属性的封装，一个人的姓名，年龄，妻子都是这个对象（人）的私有属性 private String name; private int age; private Woman wife; //对改人对外界提供方法的封装，可以设定妻子，姓名，年龄也可以获得男人的姓名和年龄public void setWife(Woman wife) { this.wife = wife; } public String getName() { return name; } public void setName(String name) { https://www.doczj.com/doc/2811904948.html, = name; } public int getAge() { return age; }
{ this.age = age; } } public class Woman { //属性封装 private String name; private int age; private Man husband; //方法封装 public String getName() { return name; } public void setName(String name) { https://www.doczj.com/doc/2811904948.html, = name; } public int getAge() { return age; }
{ this.age = age; } public Man getHusband() { return husband; } public void setHusband(Man husband) { this.husband = husband; } } /** * 仔细看就会发现，Man类没有提供getWife的方法，这是以为男人不想让自己的妻子被外界访问，* * 直接下来呢，就是封装可以吧一个对象的属性私有，而提供一些可以被外界访问的属性的方法， * * 比如说，name属性，Man和Woman类都有相应的get和set方法，外界都可以通过这些方法访问和修改 * * 同时对一些改对象不想让外界访问的属性，就不提供其方法，比如说Man的wife属性，就没有get 方法 * * 外界是不能带到Man类的wife属性的
编写一个JAVA类和一个JSP页面，把下列信息封装到3个Student对象里，再把每个对象放到一个ArrayList对象里，再利用ArrayList对象在JSP页面的表格中显示所下表所示的信息 package st.jsp; import java.util.ArrayList; public class student { public int num; public String name; public String sex; public int cla; public int sore; public student(int num,String name,String sex,int cla,int sore){ this.num=num; https://www.doczj.com/doc/2811904948.html,=name; this.sex=sex; this.cla=cla; this.sore=sore; } public static void main(String []arg){ ArrayList
request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/"; %>