package com.company;
//一个源文件只能有一个public类,源文件名和public类的类名保持一致
//一个源文件可以有多个非public类
//如果一个类定义在某个包里,那么package语句应该在源文件的首行
//如果源文件包含import语句,那么应该放在package语句和类定义之间,如果没有package语句,import语句应该放到源文件的最前面
//import语句和package语句对源文件中定义的所有类都有效,同一源文件中,不能给不同的类不同的包声明
public class Puppy {
static int a; //类变量 ,定义在类中,方法体外,被static声明
int puppyAge; //成员变量
public Puppy(String name){
//构造器,构造器参数是name
int b; //局部变量
System.out.println("小狗的名字是:"+name);
}
public void setAge(int age){
puppyAge = age;
}
public int getAge(){
System.out.println("小狗的年龄为:"+puppyAge);
return puppyAge;
}
public static void main(String[] args){
Puppy mypuppy = new Puppy("tommy");
mypuppy.setAge(2);
int age = mypuppy.getAge();
System.out.println("变量值:"+mypuppy.puppyAge);
System.out.println(age);
}
}
/*
1,构造方法的名字和类名相同,并且没有返回值
2,构造方法主要用于为类的对象定义初始化状态
3,我们不能直接调用构造方法,必须通过new关键词来自动调用,从而创建类的实例
4,java的类都要求有构造方法,如果没有定义构造方法,java编译器会为我们提供一个缺省的构造方法,也就是不带参数的构造方法,python中的__init__
new关键词的作用
1,为对象分配内存空间
2,引起对象构造方法的调用
3,为对象返回一个引用
*/
/*
不使用内部类
public class Person {
private int blood;
private Heart heart;
}
public class Heart {
private int blood;
public void test() {
System.out.println(blood);
}
}
使用内部类
public class Person {
private int blood;
public class Heart {
public void test() {
System.out.println(blood);
}
}
public class Brain {
public void test() {
System.out.println(blood);
}
}
}
内部类优点和缺点：
优点：可访问外部类私有属性
缺点：破坏原有类的程序结构（属性、构造方法、普通方法、内部类）
应用举例
//外部类
class Out {
private int age = 12;
//内部类
class In {
public void print() {
System.out.println(age);
}
}
}
public class Demo {
public static void main(String[] args) {
Out.In in = new Out().new In();
in.print();
//或者采用下种方式访问
//Out out = new Out();
//Out.In in = out.new In();
//in.print();
}
}
*/
/*
java中this和super用法
this指向对象本身的指针,形参与成员名字重名,用this来区分
super超(父)类对象的一个指针
class Person {
public static void prt(String s) {
System.out.println(s);
}
Person() {
prt("父类·无参数构造方法： "+"A Person.");
}//构造方法(1)
Person(String name) {
prt("父类·含一个参数的构造方法： "+"A person's name is " + name);
}//构造方法(2)
}
public class Chinese extends Person {
Chinese() {
super(); // 调用父类构造方法（1）
prt("子类·调用父类”无参数构造方法“： "+"A chinese coder.");
}
Chinese(String name) {
super(name);// 调用父类具有相同形参的构造方法（2）
prt("子类·调用父类”含一个参数的构造方法“： "+"his name is " + name);
}
Chinese(String name, int age) {
this(name);// 调用具有相同形参的构造方法（3）,即调用上一个构造方法 Chinese(String name)
prt("子类：调用子类具有相同形参的构造方法：his age is " + age);
}
public static void main(String[] args) {
Chinese cn = new Chinese();
cn = new Chinese("codersai");
cn = new Chinese("codersai", 18);
}
}
父类·无参数构造方法： A Person.
子类·调用父类”无参数构造方法“： A chinese coder.
父类·含一个参数的构造方法： A person's name is codersai
子类·调用父类”含一个参数的构造方法“： his name is codersai
父类·含一个参数的构造方法： A person's name is codersai
子类·调用父类”含一个参数的构造方法“： his name is codersai
子类：调用子类具有相同形参的构造方法：his age is 18
*/
/*
final double PI = 3.1415927; 定义常量
字面量
byte a = 68;
char a = 'A'
进制
int decimal = 100; 十进制
int octal = 0144; 前缀0表示8进制
int hexa = 0x64; 前缀0x代表16进制
字符串常量和字符常量都可以包含任何Unicode字符
char a = '\u0001';
String a = '\u0001';
java支持一些特殊转义字符序列
\n 换行(0x0a)
\r 回车(0x0d)
\f 换页符(0x0c)
\b 退格(0x08)
\0 空字符(0x20)
\s 字符串
\t 制表符
\" 双引号
\' 单引号
\\ 反斜杠
\ddd 八进制字符(ddd)
\uxxxx 16进制Unicode字符(xxxx)
类型转换
byte(8位,-128~127) ,short(16位,-32768~32767) ,char(16位,0~65535) , int(32位,-2147483648~2147483647), long(64位,-9223372036854775808~9223372036854775807),float(32位,1.4E-45~3.4028235E38),double(64位,4.9E-324~1.7976931348623157E308) 由低级到高级
低精度可以自动转为高精度
public class ZiDongLeiZhuan{
public static void main(String[] args){
char c1='a';//定义一个char类型 //c1 的值为字符 a ,查 ASCII 码表可知对应的 int 类型值为 97， A 对应值为 65
int i1 = c1;//char自动类型转换为int
System.out.println("char自动类型转换为int后的值等于"+i1); //97
char c2 = 'A';//定义一个char类型
int i2 = c2+1;//char 类型和 int 类型计算
System.out.println("char类型和int计算后的值等于"+i2); //66
}
}
强制类型转化
public class QiangZhiZhuanHuan{
public static void main(String[] args){
int i1 = 123;
byte b = (byte)i1;//强制类型转换为byte
System.out.println("int强制类型转换为byte后的值等于"+b); //123
}
}
隐含强制类型转换
1. 整数的默认类型是 int
2. 浮点型不存在这种情况，因为在定义 float 类型时必须在数字后面跟上 F 或者 f
Java 里使用 long 类型的数据一定要在数值后面加上 L，否则将作为整型解析：
long value = 9223372036854775807L;
包装类过度类型转化
先声明一个变量，然后生成一个对应的包装类，就可以利用包装类的各种方法进行类型转换了
float f1=100.00f;
Float F1=new Float(f1);
double d1=F1.doubleValue();//F1.doubleValue()为Float类的返回double值型的方法
简单类型的变量转换为相应的包装类，可以利用包装类的构造函数。即：Boolean(boolean value)、Character(char value)、Integer(int value)、Long(long value)、Float(float value)、Double(double value)
而在各个包装类中，总有形为××Value()的方法，来得到其对应的简单类型数据。利用这种方法，也可以实现不同数值型变量间的转换，例如，对于一个双精度实型类，intValue()可以得到其对应的整型变量，而doubleValue()可以得到其对应的双精度实型变量。
字符串于其他类型间的转换
其他类型转化为字符串
1,调用类的串转换方法:X.toString();
2,自动转换: X +"";
3,使用String的方法 String.valueOf(X);
字符串作为值,想其它类型的转换
1,先转换成相应的封装器实例,再调用对应的方法转换成其它类型
例如，字符中"32.1"转换double型的值的格式为:new Float("32.1").doubleValue()。也可以用:Double.valueOf("32.1").doubleValue()
2,静态parseXXX方法
String s = "1";
byte b = Byte.parseByte( s );
short t = Short.parseShort( s );
int i = Integer.parseInt( s );
long l = Long.parseLong( s );
Float f = Float.parseFloat( s );
Double d = Double.parseDouble( s );
3,Character的getNumericValue(char ch)方法
Date类与其他数据类型的相互转换
整型和Date类之间并不存在直接的对应关系，只是你可以使用int型为分别表示年、月、日、时、分、秒，这样就在两者之间建立了一个对应关系，在作这种转换时，你可以使用Date类构造函数的三种形式：
Date(int year, int month, int date)：以int型表示年、月、日
Date(int year, int month, int date, int hrs, int min)：以int型表示年、月、日、时、分
Date(int year, int month, int date, int hrs, int min, int sec)：以int型表示年、月、日、时、分、秒
在长整型和Date类之间有一个很有趣的对应关系，就是将一个时间表示为距离格林尼治标准时间1970年1月1日0时0分0秒的毫秒数。对于这种对应关系，Date类也有其相应的构造函数：Date(long date)。
获取Date类中的年、月、日、时、分、秒以及星期你可以使用Date类的getYear()、getMonth()、getDate()、getHours()、getMinutes()、getSeconds()、getDay()方法，你也可以将其理解为将Date类转换成int。
而Date类的getTime()方法可以得到我们前面所说的一个时间对应的长整型数，与包装类一样，Date类也有一个toString()方法可以将其转换为String类。
有时我们希望得到Date的特定格式，例如20020324，我们可以使用以下方法，首先在文件开始引入：
import java.text.SimpleDateFormat;
java.util.Date date = new java.util.Date();
//如果希望得到YYYYMMDD的格式
SimpleDateFormat sy1=new SimpleDateFormat("yyyyMMdd");
String dateFormat=sy1.format(date);
//如果希望分开得到年，月，日
SimpleDateFormat sy=new SimpleDateFormat("yyyy");
SimpleDateFormat sm=new SimpleDateFormat("MM");
SimpleDateFormat sd=new SimpleDateFormat("dd");
String syear=sy.format(date);
String smon=sm.format(date);
String sday=sd.format(date);
总结
1、只有 boolean 不参与数据类型的转换
2、自动类型的转换：
a.常数在表数范围内是能够自动类型转换的
b.数据范围小的能够自动数据类型大的转换（注意特例）
float 到 int，float 到 long，double 到 int，double 到 long 等由浮点类型转换成整数类型时，是不会自动转换的，不然将会丢失精度。
c.引用类型能够自动转换为父类的
d.基本类型和它们包装类型是能够互相转换的
3、强制类型转换：用圆括号括起来目标类型，置于变量前
private static final double PI = 3.14;
private子类不可用（与类继承关系） + static非静态方法不可用（与方法的关系）+ final常量（与变量的关系） + double类型（与其他类型的关系）
public class Xix {
// 静态成员
public static String string="static成员";
// 普通成员
public String string2="非static成员";
// 静态方法
public static void method(){
string="sss";
//string2="sss";编译报错,因为静态方法里面只能调用静态方法或静态成员
//method2();
System.out.println("这是static方法,static方法与对象无关");
}
// 普通方法
public void method2(){
string ="string1";
string2="string2";
method(); //非静态方法里面可以发出对static方法的调用
System.out.println("这是非static方法,此方法必须和指定的对象关联起来才起作用");
}
public static void main(String[] args) {
Xix x=new Xix();
x.method2();// 引用调用普通方法
x.method();// 引用调用静态方法
}
}
访问控制修饰符
default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
public : 对所有类可见。使用对象：类、接口、变量、方法
protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
私有访问修饰符-private
私有访问修饰符是最严格的访问级别，所以被声明为 private 的方法、变量和构造方法只能被所属类访问，并且类和接口不能声明为 private。
声明为私有访问类型的变量只能通过类中公共的 getter 方法被外部类访问。
Private 访问修饰符的使用主要用来隐藏类的实现细节和保护类的数据。
public class Logger {
private String format;
public String getFormat() {
return this.format;
}
public void setFormat(String format) {
this.format = format;
}
}
实例中，Logger 类中的 format 变量为私有变量，所以其他类不能直接得到和设置该变量的值。为了使其他类能够操作该变量，定义了两个 public 方法：getFormat() （返回 format的值）和 setFormat(String)（设置 format 的值）
公有访问修饰符-public
被声明为 public 的类、方法、构造方法和接口能够被任何其他类访问。
如果几个相互访问的 public 类分布在不同的包中，则需要导入相应 public 类所在的包。由于类的继承性，类所有的公有方法和变量都能被其子类继承。
受保护的访问修饰符-protected
protected 需要从以下两个点来分析说明：
子类与基类在同一包中：被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问；
子类与基类不在同一包中：那么在子类中，子类实例可以访问其从基类继承而来的 protected 方法，而不能访问基类实例的protected方法。
protected 可以修饰数据成员，构造方法，方法成员，不能修饰类（内部类除外）
访问控制和继承
父类中声明为 public 的方法在子类中也必须为 public
父类中声明为 protected 的方法在子类中要么声明为 protected，要么声明为 public，不能声明为 private。
父类中声明为 private 的方法，不能够被继承。
非访问修饰符
static 用于修饰类方法和类变量
final 用于修饰类,方法和变量,final修饰的类不能被继承,修饰的方法不能被继承类的方法重新定义,修饰的的变量为常量,是不可修改的
abstract 用来创建抽象类和抽象方法(抽象类不能用来实例化对象,声明抽象类的唯一目的是为了将来对该类进行扩充,如果一个类包含抽象方法,那么该类一定要声明为抽象类)
synchronized 和 volatile 修饰符,主要用于线程的编程 (synchronnised声明的方法同一时间只能被一个线程访问,volatile修饰的成员变量在每次被线程访问时,都强制从共享内存中重新读取改成员变量的值,而且当成员变量发生变化时,会强制线程将变化值写回到共享内存,这样在任何时刻,两个不同的线程总能看到某个成员变量的同一个
值)
*/
/*
位运算符
A = 60 (111100), B=13 (1101)
& 如果相对应位都是1，则结果为1，否则为0 （A＆B），得到12，即0000 1100
| 如果相对应位都是0，则结果为0，否则为1 （A | B）得到61，即 0011 1101
^ 如果相对应位值相同，则结果为0，否则为1 （A ^ B）得到49，即 0011 0001
〜 按位取反运算符翻转操作数的每一位，即0变成1，1变成0。 （〜A）得到-61，即1100 0011
<< 按位左移运算符。左操作数按位左移右操作数指定的位数。 A << 2得到240，即 1111 0000
>> 按位右移运算符。左操作数按位右移右操作数指定的位数。 A >> 2得到15即 1111
>>> 按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。 A>>>2得到15即0000 1111
逻辑运算符
&& 与运算,两个操作数都为真,条件才为真
|| 或运算,两个操作数任何一个未真,条件为真
! 非运算,反转操作数的逻辑状态
三元运算符 ?:
b = (a == 1) ? 20 : 30; // 如果 a 等于 1 成立，则设置 b 为 20，否则为 30
instanceof 运算符
用于操作对象实例,检查改对象是否是一个特定类型
String name = "James";
boolean result = name instanceof String; // 由于 name 是 String 类型，所以返回真
*/
/*
循环表达式
while(){
}
do{
}while();
for(初始化;布尔表达式;更新){
//代码语句
}
for(int x = 10;x<20;x =x+1){
System.out.println("value of x:"+x)
}
用于数组的for循环(相比于python的 for i in range(10) )
for(声明语句:表达式){
//代码语句
}
public class Test{
public static void main(String args[]){
int [] numbers = {10,20,30,40,50};
for(int x:numbers){
System.out.println(x);
}
System.out.println("\n");
String [] names = {"James","Larry","Tom","Bacy"};
for(String name:name){
System.out.println(name);
System.out.println(",");
}
}
}
break 跳出最里层循环
continue
*/
/*
条件语句 if ..else
if(布尔表达式){
}
if(布尔表达式){
}else{
}
if(布尔表达式){
}else if(){
}else if(){
}else{
}
switch(表达式){
case value:
//语句
break;
case value:
//语句
break;
default :
//语句
}
public class Test {
public static void main(String args[]){
//char grade = args[0].charAt(0);
char grade = 'C';
switch(grade)
{
case 'A' :
System.out.println("优秀");
break;
case 'B' :
case 'C' :
System.out.println("良好");
break;
case 'D' :
System.out.println("及格");
break;
case 'F' :
System.out.println("你需要再努力努力");
break;
default :
System.out.println("未知等级");
}
System.out.println("你的等级是 " + grade);
}
}
*/
/*
Number类和Math类
一般地，当需要使用数字的时候，我们通常使用内置数据类型，如：byte、int、long、double 等。
int a = 5000;
float b = 13.65f;
byte c = 0x4a;
然而，在实际开发过程中，我们经常会遇到需要使用对象，而不是内置数据类型的情形。为了解决这个问题，Java 语言为每一个内置数据类型提供了对应的包装类。
所有的包装类（Integer、Long、Byte、Double、Float、Short）都是抽象类 Number 的子类
这种由编译器特别支持的包装称为装箱，所以当内置数据类型被当作对象使用的时候，编译器会把内置类型装箱为包装类。相似的，编译器也可以把一个对象拆箱为内置类型。Number 类属于 java.lang 包。
public class Test{
public static void main(String args[]){
Integer x = 5;
x = x + 10;
System.out.println(x);
}
}
当 x 被赋为整型值时，由于x是一个对象，所以编译器要对x进行装箱。然后，为了使x能进行加运算，所以要对x进行拆箱。
Java 的 Math 包含了用于执行基本数学运算的属性和方法，如初等指数、对数、平方根和三角函数。
Math 的方法都被定义为 static 形式，通过 Math 类可以在主函数中直接调用。
public class Test {
public static void main (String []args)
{
System.out.println("90 度的正弦值：" + Math.sin(Math.PI/2));
System.out.println("0度的余弦值：" + Math.cos(0));
System.out.println("60度的正切值：" + Math.tan(Math.PI/3));
System.out.println("1的反正切值： " + Math.atan(1));
System.out.println("π/2的角度值：" + Math.toDegrees(Math.PI/2));
System.out.println(Math.PI);
}
}
Number & Math类方法
xxxValue() 将 Number 对象转换为xxx数据类型的值并返回。
compareTo() 将number对象与参数比较。
equals() 判断number对象是否与参数相等。
valueOf() 返回一个 Number 对象指定的内置数据类型
toString() 以字符串形式返回值
parseInt() 将字符串解析为int类型
abs() 返回参数的绝对值
ceil() 返回大于等于( >= )给定参数的的最小整数，类型为双精度浮点型。
floor() 返回小于等于（<=）给定参数的最大整数 。
rint() 返回与参数最接近的整数。返回类型为double。
round() 它表示四舍五入，算法为 Math.floor(x+0.5)，即将原来的数字加上 0.5 后再向下取整，所以，Math.round(11.5) 的结果为12，Math.round(-11.5) 的结果为-11。
min() 返回两个参数中的最小值
max() 返回两个参数中的最大值。
exp() 返回自然数底数e的参数次方。
log() 返回参数的自然数底数的对数值。
pow() 返回第一个参数的第二个参数次方。
sqrt() 求参数的算术平方根。
sin() 求指定double类型参数的正弦值。
cos() 求指定double类型参数的余弦值。
tan() 求指定double类型参数的正切值
asin() 求指定double类型参数的反正弦值
acos() 求指定double类型参数的反余弦值
atan() 求指定double类型参数的反正切值
atan2() 将笛卡尔坐标转换为极坐标，并返回极坐标的角度值
toDegrees() 将参数转化为角度
toRadians() 将角度转换为弧度。
random() 返回一个随机数
*/
/*
Character类
Character 类用于对单个字符进行操作。
使用char
char ch = 'a';
// Unicode 字符表示形式
char uniChar = '\u039A';
// 字符数组
char[] charArray ={ 'a', 'b', 'c', 'd', 'e' };
在某些情况下，Java编译器会自动创建一个Character对象。
例如，将一个char类型的参数传递给需要一个Character类型参数的方法时，那么编译器会自动地将char类型参数转换为Character对象。 这种特征称为装箱，反过来称为拆箱。
// 原始字符 'a' 装箱到 Character 对象 ch 中
Character ch = 'a';
// 原始字符 'x' 用 test 方法装箱
// 返回拆箱的值到 'c'
char c = test('x');
Character方法
isLetter() 是否是一个字母
isDigit() 是否是一个数字字符
isWhitespace() 是否是一个空白字符
isUpperCase() 是否是大写字母
isLowerCase() 是否是小写字母
toUpperCase() 指定字母的大写形式
toLowerCase() 指定字母的小写形式
toString() 返回字符的字符串形式，字符串的长度仅为1
*/
/*
String类
字符串广泛应用 在 Java 编程中，在 Java 中字符串属于对象，Java 提供了 String 类来创建和操作字符串。
创建字符串最简单的方式如下:
String greeting = "菜鸟教程";
通过提供字符串数组初始化字符串
public class StringDemo{
public static void main(String args[]){
char[] helloArray = { 'r', 'u', 'n', 'o', 'o', 'b'};
String helloString = new String(helloArray);
System.out.println( helloString ); //runoob
}
}
字符串长度 string.length()
连接字符串 string1.concat(string2) 或者使用 + ,string1+string2
格式化字符串
System.out.printf("浮点型变量的值为 " +
"%f, 整型变量的值为 " +
" %d, 字符串变量的值为 " +
"is %s", floatVar, intVar, stringVar);
或者
String fs;
fs = String.format("浮点型变量的值为 " +
"%f, 整型变量的值为 " +
" %d, 字符串变量的值为 " +
" %s", floatVar, intVar, stringVar);
String方法
char charAt(int index) 返回指定索引处的 char 值。
int compareTo(Object o) 把这个字符串和另一个对象比较
int compareTo(String anotherString) 按字典顺序比较两个字符串
int compareToIgnoreCase(String str) 按字典顺序比较两个字符串，不考虑大小写
String concat(String str) 将指定字符串连接到此字符串的结尾。
boolean contentEquals(StringBuffer sb) 当且仅当字符串与指定的StringBuffer有相同顺序的字符时候返回真
static String copyValueOf(char[] data) 返回指定数组中表示该字符序列的 String。
static String copyValueOf(char[] data, int offset, int count) 返回指定数组中表示该字符序列的 String。
boolean endsWith(String suffix) 测试此字符串是否以指定的后缀结束
boolean equals(Object anObject) 将此字符串与指定的对象比较。
boolean equalsIgnoreCase(String anotherString) 将此 String 与另一个 String 比较，不考虑大小写。
byte[] getBytes() 使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
byte[] getBytes(String charsetName) 使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 将字符从此字符串复制到目标字符数组
int hashCode() 返回此字符串的哈希码
int indexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引
int indexOf(int ch, int fromIndex) 返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索
int indexOf(String str) 返回指定子字符串在此字符串中第一次出现处的索引
int indexOf(String str, int fromIndex) 返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始
String intern() 返回字符串对象的规范化表示形式
int lastIndexOf(int ch) 返回指定字符在此字符串中最后一次出现处的索引
int lastIndexOf(int ch, int fromIndex) 返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索
int lastIndexOf(String str) 返回指定子字符串在此字符串中最右边出现处的索引
int lastIndexOf(String str, int fromIndex) 返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索
int length() 返回此字符串的长度
boolean matches(String regex) 告知此字符串是否匹配给定的正则表达式
boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len) 测试两个字符串区域是否相等
boolean regionMatches(int toffset, String other, int ooffset, int len) 测试两个字符串区域是否相等
String replace(char oldChar, char newChar) 返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的
String replaceAll(String regex, String replacement) 使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串
String replaceFirst(String regex, String replacement) 使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串
String[] split(String regex) 根据给定正则表达式的匹配拆分此字符串
String[] split(String regex, int limit) 根据匹配给定的正则表达式来拆分此字符串
boolean startsWith(String prefix) 测试此字符串是否以指定的前缀开始
boolean startsWith(String prefix, int toffset) 测试此字符串从指定索引开始的子字符串是否以指定前缀开始
CharSequence subSequence(int beginIndex, int endIndex) 返回一个新的字符序列，它是此序列的一个子序列
String substring(int beginIndex) 返回一个新的字符串，它是此字符串的一个子字符串
String substring(int beginIndex, int endIndex) 返回一个新字符串，它是此字符串的一个子字符串
char[] toCharArray() 将此字符串转换为一个新的字符数组
String toLowerCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为小写
String toLowerCase(Locale locale) 使用给定 Locale 的规则将此 String 中的所有字符都转换为小写
String toString() 返回此对象本身（它已经是一个字符串！）
String toUpperCase() 使用默认语言环境的规则将此 String 中的所有字符都转换为大写
String toUpperCase(Locale locale)使用给定 Locale 的规则将此 String 中的所有字符都转换为大写
String trim()返回字符串的副本，忽略前导空白和尾部空白
static String valueOf(primitive data type x)返回给定data type类型x参数的字符串表示形式
*/
/*
StringBuffer 和 StringBuilder 类
当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。
和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。
StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。
由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类。
public class Test{
public static void main(String args[]){
StringBuffer sBuffer = new StringBuffer("菜鸟教程官网：");
sBuffer.append("www");
sBuffer.append(".runoob");
sBuffer.append(".com");
System.out.println(sBuffer); //菜鸟教程官网：www.runoob.com
}
}
StringBuffer 方法
public StringBuffer append(String s) 将指定的字符串追加到此字符序列。
public StringBuffer reverse() 将此字符序列用其反转形式取代。
public delete(int start, int end) 移除此序列的子字符串中的字符。
public insert(int offset, int i) 将 int 参数的字符串表示形式插入此序列中。
replace(int start, int end, String str) 使用给定 String 中的字符替换此序列的子字符串中的字符。
int capacity() 返回当前容量。
char charAt(int index) 返回此序列中指定索引处的 char 值。
void ensureCapacity(int minimumCapacity) 确保容量至少等于指定的最小值。
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 将字符从此序列复制到目标字符数组 dst。
int indexOf(String str) 返回第一次出现的指定子字符串在该字符串中的索引。
int indexOf(String str, int fromIndex) 从指定的索引处开始，返回第一次出现的指定子字符串在该字符串中的索引。
int lastIndexOf(String str) 返回最右边出现的指定子字符串在此字符串中的索引。
int lastIndexOf(String str, int fromIndex) 返回 String 对象中子字符串最后出现的位置。
int length() 返回长度（字符数）。
void setCharAt(int index, char ch) 将给定索引处的字符设置为 ch。
void setLength(int newLength) 设置字符序列的长度。
CharSequence subSequence(int start, int end) 返回一个新的字符序列，该字符序列是此序列的子序列。
String substring(int start) 返回一个新的 String，它包含此字符序列当前所包含的字符子序列。
String substring(int start, int end) 返回一个新的 String，它包含此序列当前所包含的字符子序列。
String toString() 返回此序列中数据的字符串表示形式。
*/
数据类型
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
- 文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
- 文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
- 文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
