封装，static，String类
来源：互联网 发布：淘宝客返利 编辑：程序博客网 时间：2024/04/30 02:05
一：
1.1
封装：（案例演示，创建学生类年龄可以随意被设置成不符合要求的参数）
是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
好处： A:提高了代码的复用性 B:提高安全性。体现： 将不需要对外提供的内容都隐藏起来。 做法： 把属性隐藏，提供公共方法对其访问。现在我们可以给age赋值，但是赋予负数值居然也通过了。这是不满足实际需求的。我们应该对不满足需求的数据给与判断。而判断不能直接针对成员变量做，因为要判断，就必须写在方法中。所以，我们应该用一个方法给年龄赋值并判断。虽然我们已经通过一个方法做出了数据不正常的判断，但是我们还是可以通过对象直接访问成员变量。那么，为了让使用者使用方法来给成员变量赋值，就不能允许它们直接去访问成员变量。怎么办呢? 为了解决这种情况，java就提供了一个修饰符关键字：privateprivate： 私有的意思。 可以修饰成员变量和成员方法。 特点： 被private修饰的内容，只能在本类中访问。1.2封装加入private后的标准代码：A:把成员变量private修饰B:针对每一个成员变量给出 getXxx()和setXxx()（注意首字母大写） 注意：这里的xxx其实是成员变量名称。二：this关键字详解（演示修改局部变量的变量名和成员变量相同的话的效果）
常说：
见名知意。
局部变量如果有一个变量和成员变量名称一致，那么优先使用的是局部变量。就近原则。这样的话，就造成了局部变量隐藏了成员变量。如何解决呢? 为了解决这种情况，java就提供了一个代表本类对象的关键字：this三：构造方法
3.1
构造方法：
作用：给对象的数据进行初始化
格式特点：
A:方法名和类名相同。
public void Student() {}
B:没有返回值类型。
修饰符 返回值类型 方法名(…) {…}
C:没有返回值。
没有用return带明确的值回来。
return;
3.2构造方法注意事项 A:如果你不提供构造方法，系统会给出默认无参构造方法 B:如果你提供了构造方法，系统将不再提供默认无参构造方法 这个时候怎么办呢? a:使用自己给的带参构造。 b:要么自己再提供一个无参构造 建议：建议永远自己给出无参构造方法。 C:构造方法也是可以重载的。3.3给成员变量赋值： A:通过setXxx()方法 B:通过带参构造方法 四：
成员方法：
去掉static的方法。
根据返回值类型： void类型 非void类型根据参数列表： 无参 带参 五：
标准代码的写法：
练习：
手机类：
成员变量：
brand,price,color
构造方法：
无参，带参
成员方法：
getXxx()/setXxx()
show(),call()
练习：
学生类：
成员变量：
name,age,address
构造方法：无参，带参
成员方法：getXxx()/setXxx() show(),study() 六：
6.1 测试标准手机代码（两种创建对象方式，分别进行演示） package com.edu_04;
/**
* 五：
标准代码的写法：
练习：
手机类：
成员变量：
brand,price,color
构造方法：
无参，带参
成员方法：
getXxx()/setXxx()
show(),call()
一个标准的java描述类： 1.私有化成员变量 2.为私有化的成员变量提供set/get方法 3.提供有参数和无参数的构造方法 4.还需要写一个功能性的方法*
*/
public class Phone {
//提供私有化的成员变量
private String brand;
private int price;
private String color;
//为私有化的成员变量提供set/get方法public void setBrand(String brand){ this.brand = brand;}public String getBrand(){ return brand;}public void setPrice(int price){ this.price = price;}public int getPrice(){ return price;}public void setColor(String color){ this.color = color;}public String getColor(){ return color;}//提供有参数和无参数的构造方法public Phone(){}public Phone(String brand,int price,String color){ this.brand = brand; this.price = price; this.color = color;}//提供功能性的方法public void call(){ System.out.println("手机可以打电话");}public void show(){ //show方法打印三个成员变量 System.out.println(brand+" "+price+" "+color);}}
package com.edu_04;
public class Test {
public static void main(String[] args) {
//创建一个手机对象，使用set方法给对象赋值（无参构造+set方法）
Phone p = new Phone();
p.setBrand(“华为”);
p.setColor(“黑色”);
p.setPrice(2000);
System.out.println(p.getBrand()+” “+p.getColor()+” “+p.getPrice());
System.out.println("-----------------------------"); //使用有参构造创建对象并且给对象赋值 Phone p2 = new Phone("苹果", 5000, "土豪金"); System.out.println(p2.getBrand()+" "+p2.getColor()+" "+p2.getPrice()); System.out.println("-----------------------------"); p2.call(); p2. show();}}
七：
面向对象练习：
7.1 定义一个类MyMath,提供基本的加减乘除功能，然后进行测试。
add(int a,int b)
sub(int a,int b)
mul(int a,int b)
div(int a,int b)
package com.edu_06;
public class MyMath {
//加法public int add(int a,int b){ return a+b;}//减法public int sub(int a,int b){ return a-b;}//乘法public int mul(int a,int b){ return a*b;}//除法public int div(int a,int b){ return a/b;}}
package com.edu_06;
public class MyMathTest {
public static void main(String[] args) {
//创建MyMath对象
MyMath my = new MyMath();
//调用这个对象的加减乘除的功能 System.out.println(my.add(10, 20)); System.out.println(my.sub(20, 10)); System.out.println(my.mul(10, 20)); System.out.println(my.div(20, 10));}}
7.2
定义一个长方形类,定义求周长和面积的方法，然后定义一个测试了Test2，进行测试。
周长：2*(长+宽)
面积：长*宽
变量的定义：
范围越小越好。
但是，如果这个变量和类有描述关系，就应该定义为成员变量。
package com.edu_07;
/**
* 定义一个长方形类,定义求周长和面积的方法，然后定义一个测试了Test2，进行测试。
周长：2*(长+宽)
面积：长*宽
*/
public class Rectangle {
//提供一个求周长的方法public int zhouChang(int width,int height){ return 2*(width+height);}//求面积的方法public int getArear(int width,int height){ return width*height;}}
package com.edu_07;
public class Test {
public static void main(String[] args) {
//创建对象
Rectangle r = new Rectangle();
int zhouChang = r.zhouChang(10, 20);
System.out.println(zhouChang);
int arear = r.getArear(10, 20);
System.out.println(arear);
}
}
八：
static关键字
8.1
为了体现共用的数据，java就提供了一个关键字：static。
static:
作用：可以修饰成员变量和成员方法
特点： A:随着类的加载而加载 B:优先于对象存在 C:被类的所有对象共享 也是我们判断该不该使用静态修饰一个数据的依据。 举例： 饮水机：static 水杯：特有的内容。 D:可以通过类名调用 静态变量：类变量 非静态变量：实例变量，对象变量 非静态的：创建对象访问 静态的：可以通过类名，也可以通过对象访问。8.2（写一个静态成员变量和静态成员方法进行演示）
static关键字注意事项
A:在静态方法中是没有this关键字的
原因：静态的内容随着类的加载而加载，this是随着对象的创建而存在，所以，static中不能有this。
B:静态方法只能访问静态的成员变量和静态的成员方法
静态方法只能访问静态的成员。
九：
API帮助文档使用简单讲解+java中的常用的一些包的讲解
十：
String类讲解 char[] chs = {‘a’,’b’,’c’};
(1) 是由多个字符组成的一串数据。(字符序列)
其实字符串可以看成是一个字符数组。
(2)构造方法： public String():无参构造方法 public String(byte[] bytes):把字节数组转换为字符串 public String(char[] value):把字符数组转换为字符串 public String(char[] value,int offset,int count):把字符数组的一部分转换为字符串 public String(String original):把一个字符串转换为字符串（需要利用到的一个成员方法）成员方法： public int length()：返回此字符串的长度(3)String的特点及面试题 A： String类的数据特点： 字符串是常量；它们的值在创建之后不能更改 面试题：根据以上结论请问输出的s的值是多少 String s = "hello"; s += "world"; System.out.println(s); 结论： 字符串的内容不能发生改变，但是字符串引用的指向是可以改变的。 B:String s = new String("hello")和String s = "hello"的区别（画图讲解） 前者创建了1个或者2个对象 后缀创建了0个或者1个对象 C:面试题(看程序写结果) A:new和直接赋值的区别 String s1 = new String("hello"); String s2 = new String("hello"); System.out.println(s1==s2); System.out.println(s1.equals(s2)); String s3 = new String("hello"); String s4 = "hello"; System.out.println(s3==s4); System.out.println(s3.equals(s4)); String s5 = "hello"; String s6 = "hello"; System.out.println(s5==s6); System.out.println(s5.equals(s6)); D：面试题： String s1 = "hello"; String s2 = "world"; String s3 = "helloworld"; System.out.println(s3 == s1 + s2); System.out.println(s3.equals(s1 + s2)); System.out.println(s3 == "hello" + "world"); System.out.println(s3.equals("hello" + "world")); 结论： 看程序写结果 变量相加，先开空间，在加。 常量相加，先加，找是否有这样的数据空间，如果没有才开空间。(4)String类的成员方法 A:判断功能 boolean equals(Object obj):比较两个字符串的内容是否相同,严格区分大小写。(用户名,密码) boolean equalsIgnoreCase(String str):比较两个字符串的内容是否相同,忽略大小写。(验证码) boolean contains(String str):判断字符串中是否包含一个子串。 boolean startsWith(String str):判断是否以指定的字符串开头 boolean endsWith(String str):判断是否以指定的字符串结尾 boolean isEmpty():判断字符串的内容是否为空 问题：内容为空和对象为空是一个意思吗? 答：不是 B:获取功能 String类的获取功能： int length():返回字符串的长度。其实就是字符的个数。 char charAt(int index):返回字符串中指定索引处的字符。 int indexOf(int ch):返回指定的字符在字符串中第一次出现的索引。 明明说的是字符，为什么是int呢? 原因是int类型还可以接收char类型。 97,'a'是一样的效果。 但是如果参数是char类型，你就不能写97了。 int indexOf(String str):返回指定的字符串在字符串中第一次出现的索引。 String substring(int start):截取从start开始到末尾的字符串。 String substring(int start,int end):截取从start开始到end结束的字符串。 C:转换功能 byte[] getBytes():把字符串转换为字节数组 char[] toCharArray():把字符串转换为字符数组 static String valueOf(char[] chs):把字符数组转换为字符串 static String valueOf(int i):把int类型的数据转换为字符串 valueOf():可以把任意类型的数据转换为字符串。 String toLowerCase():把字符串转成小写 String toUpperCase():把字符串转成大写 String concat(String str):拼接字符串,前面我们使用过+进行字符串的拼接，不够专业。 D:其他功能 A:替换功能 String replace(char old,char new) String replace(String old,String new) B:去除字符串两端空格 String trim() package com.edu_10;/**
* (2)构造方法：
public String():无参构造方法
public String(byte[] bytes):把字节数组转换为字符串
public String(char[] value):把字符数组转换为字符串
public String(char[] value,int offset,int count):把字符数组的一部分转换为字符串
public String(String original):把一个字符串转换为字符串
*
*/
public class StringDemo {
public static void main(String[] args) {
/*//public String():无参构造方法
String s = new String();//创建一个一个空字符串：””
s = “hello”;//引用的指向本质上已经发生了变化
System.out.println(s);*/
System.out.println("-------------------"); /*//public String(byte[] bytes):把字节数组转换为字符串 String s = "hello"; byte[] bys = s.getBytes(); String s2 = new String(bys); System.out.println(s2);*/ System.out.println("--------------------"); //public String(char[] value):把字符数组转换为字符串 /*char[] chs = {'a','b','c','d'}; String s = new String(chs); System.out.println(s);*/ System.out.println("--------------------"); //public String(char[] value,int offset,int count):把字符数组的一部分转换为字符串 /*char[] chs = {'a','b','c','d'}; String s = new String(chs, 2,2);//offect:开始的索引 count:从开始索引开始向后获取多少个字符 System.out.println(s);*/ System.out.println("--------------------"); //public String(String original):把一个字符串转换为字符串 String s = new String("hello"); System.out.println(s); /** * （需要利用到的一个成员方法）成员方法： public int length()：返回此字符串的长度 */ System.out.println(s.length());}}
重点二
package com.edu_10;
/**
* A：
String类的数据特点：
字符串是常量；它们的值在创建之后不能更改
面试题：根据以上结论请问输出的s的值是多少
String s = “hello”;
s += “world”;
System.out.println(s);
注意：字符串被创建之后是不能被改变的，但是他的引用的指向可以发生改变*/
public class StringDemo2 {
public static void main(String[] args) {
String s = “hello”;
s += “world”;
System.out.println(s);
}
}
重点三
package com.edu_10;
public class StringDemo4 {
public static void main(String[] args) {
String s1 = “hello”;
String s2 = “world”;
String s3 = “helloworld”;
System.out.println(s3 == s1 + s2); //fasle
System.out.println(s3.equals(s1 + s2)); //true
System.out.println(s3 == "hello" + "world"); //true System.out.println(s3.equals("hello" + "world")); //true /** * 变量相加和常量相加的区别？ * 变量相加：先在内存中开辟空间，再去做加法 * 常量相加：先加，找是否有这样的数据空间，如果没有才开空间。 */}}
重点四
package com.edu_10;
/**
A:判断功能
boolean equals(Object obj):比较两个字符串的内容是否相同,严格区分大小写。(用户名,密码)
boolean equalsIgnoreCase(String str):比较两个字符串的内容是否相同,忽略大小写。(验证码)
boolean contains(String str):判断字符串中是否包含一个子串。
boolean startsWith(String str):判断是否以指定的字符串开头
boolean endsWith(String str):判断是否以指定的字符串结尾
boolean isEmpty():判断字符串的内容是否为空
问题：内容为空和对象为空是一个意思吗?
答：不是
*
*/
public class StringDemo5 {
public static void main(String[] args) {
// boolean equals(Object obj):比较两个字符串的内容是否相同,严格区分大小写。(用户名,密码)
String s = “hello”;
String s2 = “Hello”;
System.out.println(s.equals(s2));
// boolean equalsIgnoreCase(String str):比较两个字符串的内容是否相同,忽略大小写。(验证码)
System.out.println(s.equalsIgnoreCase(s2));
// boolean contains(String str):判断字符串中是否包含一个子串。 System.out.println(s.contains("hel")); // boolean startsWith(String str):判断是否以指定的字符串开头 System.out.println(s.startsWith("h")); // boolean endsWith(String str):判断是否以指定的字符串结尾 System.out.println(s.endsWith("lo")); // boolean isEmpty():判断字符串的内容是否为空 //String s3 = null; String s3 = ""; /** * java.lang.NullPointerException:空指针异常 * * 对象为空：null，说明这个引用没有指向 * 字符串为空：就是一个空字符串，字符串中什么也没有 */ System.out.println(s3.isEmpty());}}
重点五
package com.edu_10;
/**
B:获取功能
String类的获取功能：
int length():返回字符串的长度。其实就是字符的个数。
char charAt(int index):返回字符串中指定索引处的字符。
int indexOf(int ch):返回指定的字符在字符串中第一次出现的索引。
明明说的是字符，为什么是int呢?
原因是int类型还可以接收char类型。
97,’a’是一样的效果。
但是如果参数是char类型，你就不能写97了。
int indexOf(String str):返回指定的字符串在字符串中第一次出现的索引。
String substring(int start):截取从start开始到末尾的字符串。
String substring(int start,int end):截取从start开始到end结束的字符串。
*
*/
public class StringDemo6 {
public static void main(String[] args) {
// int length():返回字符串的长度。其实就是字符的个数。
String s = “hello”;
System.out.println(s.length());
// char charAt(int index):返回字符串中指定索引处的字符。 System.out.println(s.charAt(0)); //int indexOf(int ch):返回指定的字符在字符串中第一次出现的索引。 System.out.println(s.indexOf('l')); //String substring(int start):截取从start开始到末尾的字符串。 String s2 = s.substring(2); System.out.println(s2); //String substring(int start,int end):截取从start开始到end结束的字符串。 System.out.println(s.substring(0, 3)); //这里的开始和结束的索引值，全部都是包前不包后}}
重点六
package com.edu_10;
/**
C:转换功能
byte[] getBytes():把字符串转换为字节数组
char[] toCharArray():把字符串转换为字符数组
static String valueOf(char[] chs):把字符数组转换为字符串
static String valueOf(int i):把int类型的数据转换为字符串
valueOf():可以把任意类型的数据转换为字符串。
String toLowerCase():把字符串转成小写
String toUpperCase():把字符串转成大写
String concat(String str):拼接字符串,前面我们使用过+进行字符串的拼接，不够专业。
*
D:其他功能
A:替换功能
String replace(char old,char new)
String replace(String old,String new)
B:去除字符串两端空格
String trim()
*
*/
public class StringDemo7 {
public static void main(String[] args) {
// byte[] getBytes():把字符串转换为字节数组
String s = “java”;
byte[] bys = s.getBytes();
//char[] toCharArray():把字符串转换为字符数组// char[] chs = s.toCharArray();
// for (int i = 0; i < chs.length; i++) {
// System.out.println(chs[i]);
// }
//static String valueOf(char[] chs):把字符数组转换为字符串 char[] chs = {'a','v','c','d'}; String s3 = String.valueOf(chs); System.out.println(s3); String s4 = String.valueOf(12.34);//"12.34" System.out.println(s4); //String toLowerCase():把字符串转成小写 String s5 = "HELLoWoErl"; System.out.println(s5.toLowerCase()); //String toUpperCase():把字符串转成大写 System.out.println(s5.toUpperCase()); // String concat(String str):拼接字符串,前面我们使用过+进行字符串的拼接，不够专业。 String s6 = "hello"; String s7 = "world"; System.out.println(s6.concat(s7)); //String replace(char old,char new) System.out.println(s6.replace('e', 'a')); //String replace(String old,String new) System.out.println(s6.replace("hel", "hal")); //String trim() String s8 = " fdv gdf gds "; System.out.println(s8); System.out.println(s8.trim());}}
重点⑦
package com.edu_10;
public class StringDemo8 {
public static void main(String[] args) {
//做一个练习
//”HElloWorld”
String s = “HElloWorld” ;
String s2 = s.substring(0, 5);
String s3 = s.substring(5);
//转换大小写带拼接 String s4 = s2.toUpperCase().concat(s3.toLowerCase()); System.out.println(s4);}}
十一：
StringBuffer和StringBuilder
11.1
* StringBuffer:
* 线程安全的可变字符序列。
*
* String和StringBuffer的区别?
* A:String的内容不可变
* B:StringBuffer的内容可变
*
* StringBuffer和StringBuilder的区别?
* A:StringBuffer 线程安全，效率低
* B:StringBuilder 线程不安全，效率高
*
* 线程安全：(同步)，效率低
* 线程不安全：(不同步)，效率高
*
* 构造方法：
* StringBuffer():构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符。
* StringBuffer(int capacity):构造一个其中不带字符的字符串缓冲区，其初始容量为 capacity个字符。
* StringBuffer(String str):构造一个其中带字符的字符串缓冲区，其初始容量为??? 个字符。
*
* 成员方法：
* public int length():返回长度（字符数）。实际值
* public int capacity():返回当前容量。 理论值
* 添加功能：添加元素，并返回本身的对象。
* A:public StringBuffer append(String str):追加数据,在末尾添加
* B:public StringBuffer insert(int offset,String str):插入数据,在指定位置添加
* 删除功能：
* public StringBuffer deleteCharAt(int index):删除指定索引处的字符
* public StringBuffer delete(int start,int end):删除从start开始到end结束的数据，包左不包右
* 替换功能：
* public StringBuffer replace(int start,int end,String str):用str替换从start到end的数据
*
* 反转功能：
* public StringBuffer reverse()
* 截取功能:返回值类型是String类型，本身没有发生改变
* public String substring(int start)
* public String substring(int start,int end)
* 相互转换：
*
* String – StringBuffer
* String s = “hello”;
// 方式1
StringBuffer sb1 = new StringBuffer(s);
// 方式2
StringBuffer sb2 = new StringBuffer();
sb2.append(s);
*
* StringBuffer – String
* StringBuffer sb = new StringBuffer(“world”);
//方式1
String s1 = sb.substring(0);
//方式2
String s2 = sb.toString();
//方式3
String s3 = new String(sb);
package com.edu_11;/**
* 构造方法：
* StringBuffer():构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符。
* StringBuffer(int capacity):构造一个其中不带字符的字符串缓冲区，其初始容量为 capacity个字符。
* StringBuffer(String str):构造一个其中带字符的字符串缓冲区，其初始容量为??? 个字符。
*
* 成员方法：
* public int length():返回长度（字符数）。实际值
* public int capacity():返回当前容量。 理论值
*
*/
public class StringBufferDemo {
public static void main(String[] args) {
//StringBuffer():构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符。
StringBuffer sb = new StringBuffer();
System.out.println(sb.length());//实际容量
System.out.println(sb.capacity());//理论容量
System.out.println("-----------------------"); //StringBuffer(int capacity):构造一个其中不带字符的字符串缓冲区，其初始容量为 capacity个字符。 StringBuffer sb2 = new StringBuffer(10); System.out.println(sb2.length()); System.out.println(sb2.capacity()); System.out.println("---------------------"); //StringBuffer(String str):构造一个其中带字符的字符串缓冲区，其初始容量为??? 个字符。 StringBuffer sb3 = new StringBuffer("hello"); System.out.println(sb3);}}
二 package com.edu_11;/**
* 添加功能：添加元素，并返回本身的对象。
* A:public StringBuffer append(String str):追加数据,在末尾添加
* B:public StringBuffer insert(int offset,String str):插入数据,在指定位置添加
*
*/
public class StringBufferDemo2 {
public static void main(String[] args) {
//A:public StringBuffer append(String str):追加数据,在末尾添加
StringBuffer sb =new StringBuffer();
// sb.append(“hello”);
// sb.append(100);
// sb.append(true);
// sb.append(‘a’);
// System.out.println(sb);
sb.append(true).append("hello").append("java").append(100); System.out.println(sb); //B:public StringBuffer insert(int offset,String str):插入数据,在指定位置添加 //sb.insert(0, "false"); sb.insert(4, "fasle"); System.out.println(sb);}}
三 package com.edu_11;/**
* 删除功能：
* public StringBuffer deleteCharAt(int index):删除指定索引处的字符
* public StringBuffer delete(int start,int end):删除从start开始到end结束的数据，包左不包右
*/
public class StringBufferDemo3 {
public static void main(String[] args) {
//public StringBuffer deleteCharAt(int index):删除指定索引处的字符
StringBuffer sb =new StringBuffer(“hello”);
//sb.deleteCharAt(1);
//System.out.println(sb);
//public StringBuffer delete(int start,int end): //删除从start开始到end结束的数据，包左不包右 sb.delete(1, 3); System.out.println(sb);}}
四
package com.edu_11;
/**
* 替换功能：
* public StringBuffer replace(int start,int end,String str):用str替换从start到end的数据
*
* 反转功能：
* public StringBuffer reverse()
* 截取功能:返回值类型是String类型，本身没有发生改变
* public String substring(int start)
* public String substring(int start,int end)
*
*/
public class StringBufferDemo4 {
public static void main(String[] args) {
//替换功能：public StringBuffer replace(int start,int end,String str):
//用str替换从start到end的数据
/* StringBuffer sb = new StringBuffer(“hello”);
sb.replace(1, 3, “ab”);
System.out.println(sb);*/
System.out.println("-----------------------"); //反转功能：public StringBuffer reverse() /*StringBuffer sb = new StringBuffer("hello"); sb.reverse(); System.out.println(sb);*/ System.out.println("-------------------"); //public String substring(int start) StringBuffer sb = new StringBuffer("hello");/* String s = sb.substring(2);
System.out.println(s);*/
//public String substring(int start,int end) String s = sb.substring(1, 4); System.out.println(s);}}
五
package com.edu_11;
/**
* String – StringBuffer
* String s = “hello”;
// 方式1
StringBuffer sb1 = new StringBuffer(s);
// 方式2
StringBuffer sb2 = new StringBuffer();
sb2.append(s);
*
*/
public class StringBufferDemo5 {
public static void main(String[] args) {
//String – StringBuffer
String s = “hello”;
// 方式1
StringBuffer sb1 = new StringBuffer(s);
// 方式2
StringBuffer sb2 = new StringBuffer();
sb2.append(s);
System.out.println("------------------------"); //StringBuffer -->>String的转换 //方式1： //substring(0)截取方法 //方式2：String(StringBuffer buffer) //方式3：调用StringBuffer中的toString()方法}}
- 封装，static，String类
- String类封装
- vs2013封装string类
- 自己封装String类
- 封装string类
- 用static和static方法封装类的例子
- static string
- String、Static
- 封装.this.static关键字 以及math类
- 自己动手封装一个string类
- 黑马程序员 String封装类
- Java static关键字--String类--StringBuilder等
- 封装-this-static
- 简单的string 类库的封装
- 使用“win32 static library”封装类的内部实现
- java第五节-类，对象，构造方法，静态-static，封装
- 封装，继承，多态，抽象类，接口，Static，super， final
- 匿名对象，封装，this,super,static main,工具类
- 手动提交事务和回滚的使用典例
- 写给初学者08_android_一些常用的控件
- 记录
- 理解java的三大特性之封装
- Faster R-CNN代码讲解
- 封装，static，String类
- 算法导论 最小堆
- 用宏定义实现 得到两个数的最值
- ADV-84-算法提高-图形输出、ADV-88-算法提高-输出正反三角形
- 连号区间数
- String之——注解发布RMI/HTTPInvoker/Hessian/Burlap服务
- FPGA Quartus Prime 16.1安装及破解
- Linux中部署tomcat下的应用
- 使用jaxb使得java对象与xml之间相互转化
