博客分类：
* 封装name
public String getName() {
public void setName(String name) {
this.name =
class B extends A {
public B() {
//直接使用父类的方法
setName("name");
public String getName() {
return "name";
public String getName(String name) {
yuli001123
浏览: 25328 次
来自: 南昌
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'本心、恒心、敬畏心
HBase新版本Java API编程实战及基本操作方法封装
我的HBase版本是0.98
首先说明一下，如果用eclipse操作hbase时，如果报Unknown host错误，找不到主机，是因为你没有配IP地址的映射
方法是 找到你的系统盘里面的C:\Windows\System32\drivers\etc下的hosts文件，打开，增加一个映射
加一个映射
192.168.52.140
话不多说，直接看代码，注释很详细
import java.io.IOException
import java.util.Arrays
import java.util.List
import org.apache.hadoop.conf.Configuration
import org.apache.hadoop.hbase.Cell
import org.apache.hadoop.hbase.CellUtil
import org.apache.hadoop.hbase.HBaseConfiguration
import org.apache.hadoop.hbase.HColumnDescriptor
import org.apache.hadoop.hbase.HTableDescriptor
import org.apache.hadoop.hbase.TableName
import org.apache.hadoop.hbase.client.Admin
import org.apache.hadoop.hbase.client.Connection
import org.apache.hadoop.hbase.client.ConnectionFactory
import org.apache.hadoop.hbase.client.Delete
import org.apache.hadoop.hbase.client.Get
import org.apache.hadoop.hbase.client.Put
import org.apache.hadoop.hbase.client.Result
import org.apache.hadoop.hbase.client.ResultScanner
import org.apache.hadoop.hbase.client.Scan
import org.apache.hadoop.hbase.client.Table
import org.apache.hadoop.hbase.util.Bytes
public class MyHbaseApi {
public static void main(String[] args) {
Admin admin=null
Connection con=null
//1.获得配置文件对象
Configuration conf=HBaseConfiguration.create()
//设置配置参数
conf.set("hbase.zookeeper.quorum", "192.168.52.140")
//2.建立连接
con=ConnectionFactory.createConnection(conf)
//3.获得会话
admin=con.getAdmin()
//System.out.println(con)
//System.out.println(admin)
//建立数据库
//创建表名对象
TableName tn=TableName.valueOf("stu")
//a.判断数据库是否存在
if(admin.tableExists(tn)){
System.out.println("====& 表存在，删除表....")
//先使表设置为不可编辑
admin.disableTable(tn)
admin.deleteTable(tn)
System.out.println("表删除成功.....")
System.out.println("===&表不存在,创建表......")
//创建表结构对象
HTableDescriptor htd=new HTableDescriptor(tn)
//创建列族结构对象
HColumnDescriptor hcd1=new HColumnDescriptor("fm1")
HColumnDescriptor hcd2=new HColumnDescriptor("fm2")
htd.addFamily(hcd1)
htd.addFamily(hcd2)
admin.createTable(htd)
System.out.println("创建表成功...")
//向表中插入数据
//a.单个插入
Put put =new Put(Bytes.toBytes("row01"))
put.addColumn(Bytes.toBytes("fm1"), Bytes.toBytes("col1"), Bytes.toBytes("value01"))
//获得表对象
Table table=con.getTable(tn)
table.put(put)
//批量插入
Put put01 =new Put(Bytes.toBytes("row02"))
put01.addColumn(Bytes.toBytes("fm2"), Bytes.toBytes("col2"), Bytes.toBytes("value02")).
addColumn(Bytes.toBytes("fm2"), Bytes.toBytes("col3"), Bytes.toBytes("value03"))
Put put02 =new Put(Bytes.toBytes("row03"))
put02.addColumn(Bytes.toBytes("fm1"), Bytes.toBytes("col4"), Bytes.toBytes("value04"))
List&Put& puts=Arrays.asList(put01,put02)
//获得表对象
Table table02=con.getTable(tn)
table02.put(puts)
//读取操作
Scan scan=new Scan()
//获得表对象
Table table03=con.getTable(tn)
//得到扫描的结果集
ResultScanner rs=table03.getScanner(scan)
for(Result result:rs){
//得到单元格集合
List&Cell& cs=result.listCells()
for(Cell cell:cs){
String rowKey=Bytes.toString(CellUtil.cloneRow(cell))
//取到时间戳
long timestamp = cell.getTimestamp()
//取到族列
String family = Bytes.toString(CellUtil.cloneFamily(cell))
//取到修饰名
String qualifier
= Bytes.toString(CellUtil.cloneQualifier(cell))
String value = Bytes.toString(CellUtil.cloneValue(cell))
System.out.println(" ===& rowKey : " + rowKey + ",
timestamp : " +
timestamp + ", family : " + family + ", qualifier : " + qualifier + ", value : " + value)
System.out.println(" ===================get取数据==================")
Get get = new Get(Bytes.toBytes("row02"))
get.addColumn(Bytes.toBytes("fm2"), Bytes.toBytes("col2"))
Table t04 = con.getTable(tn)
Result r = t04.get(get)
List&Cell& cs = r.listCells()
for (Cell cell : cs) {
String rowKey = Bytes.toString(CellUtil.cloneRow(cell))
long timestamp = cell.getTimestamp()
String family = Bytes.toString(CellUtil.cloneFamily(cell))
String qualifier
= Bytes.toString(CellUtil.cloneQualifier(cell))
String value = Bytes.toString(CellUtil.cloneValue(cell))
System.out.println(" ===& rowKey : " + rowKey + ",
timestamp : " +
timestamp + ", family : " + family + ", qualifier : " + qualifier + ", value : " + value)
//删除数据
System.out.println(" ===================delete删除数据==================")
Delete delete = new Delete(Bytes.toBytes("row02"))
delete.addColumn(Bytes.toBytes("fm2"), Bytes.toBytes("col2"))
Table t05 = con.getTable(tn)
t05.delete(delete)
System.out.println(" ===================delete删除数据后==================")
scan = new Scan()
table03 = con.getTable(tn)
rs = table03.getScanner(scan)
for (Result result : rs) {
cs = result.listCells()
for (Cell cell : cs) {
String rowKey = Bytes.toString(CellUtil.cloneRow(cell))
long timestamp = cell.getTimestamp()
String family = Bytes.toString(CellUtil.cloneFamily(cell))
String qualifier
= Bytes.toString(CellUtil.cloneQualifier(cell))
String value = Bytes.toString(CellUtil.cloneValue(cell))
System.out.println(" ===& rowKey : " + rowKey + ",
timestamp : " +
timestamp + ", family : " + family + ", qualifier : " + qualifier + ", value : " + value)
} catch (IOException e) {
e.printStackTrace()
if (admin != null){
admin.close()
if(con != null){
con.close()
} catch (IOException e) {
e.printStackTrace()
下面看对于上面的基本操作的封装,封装好了，以后就可以直接用
import java.io.IOE
import java.util.HashM
import java.util.List;
import java.util.Map;
import org.apache.hadoop.conf.C
import org.apache.hadoop.hbase.C
import org.apache.hadoop.hbase.CellU
import org.apache.hadoop.hbase.HBaseC
import org.apache.hadoop.hbase.HColumnD
import org.apache.hadoop.hbase.HTableD
import org.apache.hadoop.hbase.TableN
import org.apache.hadoop.hbase.client.A
import org.apache.hadoop.hbase.client.C
import org.apache.hadoop.hbase.client.ConnectionF
import org.apache.hadoop.hbase.client.D
import org.apache.hadoop.hbase.client.G
import org.apache.hadoop.hbase.client.P
import org.apache.hadoop.hbase.client.R
import org.apache.hadoop.hbase.client.T
import org.apache.hadoop.hbase.util.Bytes;
public class HBaseUtil {
private static C
private static C
conf = HBaseConfiguration.create();
conf.set("hbase.zookeeper.quorum", "192.168.52.140");
con = ConnectionFactory.createConnection(conf);
} catch (IOException e) {
e.printStackTrace();
public static Connection getCon() {
if (con == null || con.isClosed()) {
con = ConnectionFactory.createConnection(conf);
} catch (IOException e) {
e.printStackTrace();
public static void close() {
if (con != null) {
con.close();
} catch (IOException e) {
e.printStackTrace();
public static void createTable(String tableName, String... FamilyColumn) {
TableName tn = TableName.valueOf(tableName);
Admin admin = getCon().getAdmin();
HTableDescriptor htd = new HTableDescriptor(tn);
for (String fc : FamilyColumn) {
HColumnDescriptor hcd = new HColumnDescriptor(fc);
htd.addFamily(hcd);
admin.createTable(htd);
admin.close();
} catch (IOException e) {
e.printStackTrace();
public static void dropTable(String tableName) {
TableName tn = TableName.valueOf(tableName);
Admin admin = con.getAdmin();
admin.disableTable(tn);
admin.deleteTable(tn);
admin.close();
} catch (IOException e) {
e.printStackTrace();
public static boolean insert(String tableName, String rowKey,
String family, String qualifier, String value) {
Table t = getCon().getTable(TableName.valueOf(tableName));
Put put = new Put(Bytes.toBytes(rowKey));
put.addColumn(Bytes.toBytes(family), Bytes.toBytes(qualifier),
Bytes.toBytes(value));
t.put(put);
return true;
} catch (IOException e) {
e.printStackTrace();
} finally {
HBaseUtil.close();
return false;
public static boolean del(String tableName, String rowKey, String family,
String qualifier) {
Table t = getCon().getTable(TableName.valueOf(tableName));
Delete del = new Delete(Bytes.toBytes(rowKey));
if (qualifier != null) {
del.addColumn(Bytes.toBytes(family), Bytes.toBytes(qualifier));
} else if (family != null) {
del.addFamily(Bytes.toBytes(family));
t.delete(del);
return true;
} catch (IOException e) {
e.printStackTrace();
} finally {
HBaseUtil.close();
return false;
public static boolean del(String tableName, String rowKey) {
return del(tableName, rowKey, null, null);
public static boolean del(String tableName, String rowKey, String family) {
return del(tableName, rowKey, family, null);
public static String byGet(String tableName, String rowKey, String family,
String qualifier) {
Table t = getCon().getTable(TableName.valueOf(tableName));
Get get = new Get(Bytes.toBytes(rowKey));
get.addColumn(Bytes.toBytes(family), Bytes.toBytes(qualifier));
Result r = t.get(get);
return Bytes.toString(CellUtil.cloneValue(r.listCells().get(0)));
} catch (IOException e) {
e.printStackTrace();
return null;
public static Map&String, String& byGet(String tableName, String rowKey, String family) {
Map&String, String& result = null ;
Table t = getCon().getTable(TableName.valueOf(tableName));
Get get = new Get(Bytes.toBytes(rowKey));
get.addFamily(Bytes.toBytes(family));
Result r = t.get(get);
List&Cell& cs = r.listCells();
result = cs.size() & 0 ? new HashMap&String, String&() :
for (Cell cell : cs) {
result.put(Bytes.toString(CellUtil.cloneQualifier(cell)), Bytes.toString(CellUtil.cloneValue(cell)));
} catch (IOException e) {
e.printStackTrace();
public static Map&String, Map&String, String&& byGet(String tableName, String rowKey) {
Map&String, Map&String, String&& results = null ;
Table t = getCon().getTable(TableName.valueOf(tableName));
Get get = new Get(Bytes.toBytes(rowKey));
Result r = t.get(get);
List&Cell& cs = r.listCells();
results = cs.size() & 0 ? new HashMap&String, Map&String, String&& () :
for (Cell cell : cs) {
String familyName = Bytes.toString(CellUtil.cloneFamily(cell));
if (results.get(familyName) == null)
results.put(familyName, new HashMap&String,
String& ());
results.get(familyName).put(Bytes.toString(CellUtil.cloneQualifier(cell)), Bytes.toString(CellUtil.cloneValue(cell)));
} catch (IOException e) {
e.printStackTrace();
看看测试类
package com.yc.hbase.
import static org.junit.Assert.*;
import java.util.M
import org.junit.T
public class HBaseUtilTest {
public void testCreateTable() {
HBaseUtil.createTable("myTest", "myfc1", "myfc2", "myfc3");
HBaseUtil.close();
HBaseUtil.createTable("myTest02", "myfc1", "myfc2", "myfc3");
HBaseUtil.close();
public void testDropTable() {
HBaseUtil.dropTable("myTest");
HBaseUtil.dropTable("myTest02");
public void testInsert(){
HBaseUtil.insert("myTest", "1", "myfc1", "sex", "men");
HBaseUtil.insert("myTest", "1", "myfc1", "name", "xiaoming");
HBaseUtil.insert("myTest", "1", "myfc1", "age", "32");
HBaseUtil.insert("myTest", "1", "myfc2", "name", "xiaohong");
HBaseUtil.insert("myTest", "1", "myfc2", "sex", "woman");
HBaseUtil.insert("myTest", "1", "myfc2", "age", "23");
public void testByGet(){
String result = HBaseUtil.byGet("myTest", "1", "myfc1", "name");
System.out.println("结果是的： " + result);
assertEquals("xiaosan", result);
public void testByGet02(){
Map&String, String& result = HBaseUtil.byGet("myTest", "1", "myfc1");
System.out.println("结果是的： " + result);
assertNotNull(result);
public void testByGet03(){
Map&String, Map&String, String&& result = HBaseUtil.byGet("myTest", "1");
System.out.println("所有列族的数据是:
"+result);
System.out.println("结果是的： " + result.get("myfc1"));
assertNotNull(result);
转载请指明出处
没有更多推荐了，Endure loneliness
Java封装(修饰符+包+内部类)
　　访问修饰符可以用来修饰属性和方法的访问范围。
　　如图，代表了不同的访问修饰符的访问范围，比如private修饰的属性或者方法，只能在本类中访问或者使用。默认是什么修饰符都不加，默认在当前类中和同一包下都可以访问和使用。
　　我们可以举一个例子，比如 money，如果我们用private修饰代表着这是私有的，只能我自己可以使用。如果是protected代表着我可以使用，和我有关系的人，比如儿子也可以用。如果是public就代表了所有人都可以使用。
private—–本类
默认——–本类，同包
protected–本类，同包，子类
public——-本类，同包，子类，其它
如果没有在属性前面添加任何修饰符，我们通过创建对象就可以直接对属性值进行修改，没有体现封装的特性。这在许多程序设计中都是不安全的，所以我们需要利用封装，来改进我们的代码。
首先我们的类里要将属性前添加private修饰符。然后定义getter和setter方法。
public class People{
private double
public double getHeight(){
public void setHeight(double newHeight){
height = newH
然后在我们的 main 函数里的对象，不能再直接调用属性了，只能通过getter和setter方法进行调用。
public class LiLei {
public static void main(String[] args) {
People LiLei = new People();
LiLei.setHeight(170.0);
System.out.println("LiLei的身高是"+LiLei.getHeight());
　　有时候在封装的时候会遇到这样的问题，就是我们所写程序的类名可能是重复的。这时候我们就可以用包的概念来解决我们的问题。
　　包的作用就是管理Java文件，解决同名文件冲突。这和我们生活当中的管理相类似。我们的衣柜是不是有不同的隔断和抽屉，我们将衣服分门别类地放好，是不是有利于我们管理。
　　想必大家在以前就学习过了如何定义一个包，我们使用package关键字，加上我们的包名。
定义包语法：
package 包名
//注意：必须放在源程序的第一行，包名可用”.”号隔开
//我们在定义文件夹的时候利用”/”来区分层次
//包中我们用”.”来分层
package encapsulation.Java
　　比如我们在游戏里会用到音乐类，在电影里我们也会用到音乐类，但是他们的类又不相同，我们就可以利用包进行区分。
　　不仅是我们这样利用包名来区分类，系统也是这样做的。
Java系统中的包
java.(功能).(类)
java.lang.(类)
包含java语言基础的类
java.util.(类)
包含语言中各种工具类
java.io.(类) 包含输入、输出相关的类
　　那我们怎么在不同包中使用另一个文件中的类呢？这时候就需要用到import关键字。比如我们要导入实验楼下People这个类。import com.shiyanlou.Peole，同时如果import com.shiyanlou.*这是将包下的所有文件都导入进来。
　*　这里要注意一点，包的命名规范是全小写字母拼写。*
三、Java 中的 this 关键字
　　写代码的过程中常常会用到this关键字，this关键字代表当前对象。使用this.属性操作当前对象的属性，this.方法调用当前对象的方法。
　　当我们封装对象属性的时候，经常会使用this关键字。
　　如果用private修饰的属性，我们利用对象访问的时候，必须定义getter和setter方法，（Eclipse中可以自动帮我们定义）
1、首先在菜单栏里点击Source也可以在左侧右击选择Source
创建getter和setter方法
2、选择Grenerate Getters and Setters
创建getter和setter方法
3、系统会自动帮我们检测需要创建getter和setter方法的属性，我们根据需要勾选就行了。
当系统帮我们创建好了getter和setter方法后，我们会发现系统创建的方法中参数名和我们的属性名一样。为了区分参数名和我们的属性名，我们在属性名前面添加了this关键字。
四、Java 中的内部类
问：什么是内部类呢？
答：内部类（ Inner Class ）就是定义在另外一个类里面的类。与之对应，包含内部类的类被称为外部类。
问：那为什么要将一个类定义在另一个类里面呢？清清爽爽的独立的一个类多好啊！！
答：内部类的主要作用如下：
1. 内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类
内部类的方法可以***直接访问外部类的所有数据，包括私有的数据
内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便
问：内部类有几种呢？
答：内部类可分为以下几种：
成员内部类
静态内部类
方法内部类
匿名内部类
通过代码学习一下内部类
public class People {
private String name = "LiLei";
public class Student {
String ID = "";
public void stuInfo(){
System.out.println("访问外部类中的name：" + name);
System.out.println("访问内部类中的ID：" + ID);
public static void main(String[] args) {
People a = new People();
Student b = a.new Student();
b.stuInfo();
由此，我们可以知道，成员内部类的使用方法：
Student 类相当于 People 类的一个成员变量，所以 Student 类可以使用任意访问修饰符
Student 类在 People 类里，所以访问范围在类里的所有方法均可以访问 People 的属性（即内部类里可以直接访问外部类的方法和属性，反之不行）
定义成员内部类后，必须使用外部类对象来创建内部类对象，即 内部类 对象名 = 外部类对象.new 内部类();
如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的成员变量，可以使用 this 关键字
静态内部类：
public class People {
private String name = "LiLei";
static String ID = "510xxx199X0724XXXX";
public static class Student {
String ID = "";
public void stuInfo(){
System.out.println("访问外部类中的ID：" + People.ID);
System.out.println("访问内部类中的ID：" + ID);
public static void main(String[] args) {
Student b = new Student();
b.stuInfo();
静态内部类是 static 修饰的内部类，这种内部类的特点是：
静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问
如果外部类的静态成员与内部类的成员名称相同，可通过类名.静态成员访问外部类的静态成员
如果外部类的静态成员与内部类的成员名称不相同，则可通过成员名直接调用外部类的静态成员
创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名= new 内部类()
方法内部类
　　方法内部类就是定义在外部类的方法中的内部类，方法内部类只在该方法的内部可见，即只在该方法内可以使用。
public class People {
public void peopleInfo() {
final String sex = "man";
class Student {
String ID = "";
public void print() {
System.out.println("访问外部类的方法中的常量sex：" + sex);
System.out.println("访问内部类中的变量ID:" + ID);
Student a = new Student();
a.print();
public static void main(String[] args) {
People b = new People();
b.peopleInfo();
运行结果：
访问外部类的方法中的常量sex：man
访问内部类中的变量ID：
部分参考来源：
[实验楼]（http://www.shiyanlou.com/register?inviter=NTY0MzE5MTU5NjYw）
注：如有雷同，纯属意外！如有侵权，本人立即删除
没有更多推荐了，有谁知道怎么把Java的程序封装起来吗？
全部答案（共2个回答）
Launch configuration 选择源java包
export
destination 选择将放置文件夹
如果按照面向程序编程的思维，解决一件事要先做步骤1(里面又包括步骤a，b，c....)，再做步骤2，步骤3......其中后一个步骤是在前一个步骤完成的前提下才能进行。
java是面向对象编程，你把原来的步骤1，步骤2,......分别封装成一个一个的类，每一个类解决意见事情，彼此独立但又有联系。独立是指一个类就解决一个问题，不管其他类是怎样解决另一个问题的。联系是指每个类都有一个被调用的接口，如果其他类用到这个类，直接通过接口调用，无需关注类中具体是怎样解决的。
举个例子：现在一个项目模块中有两个功能，分别由我和你来完成，现在你的功能中需要调用我的功能，那我会告诉你怎样去调用，你只要按照我的方法去调用就可以了，不用管这个功能的具体实现步骤。
差不多应该明白了吧。
个人感觉，主要还是3个方向，现在，一个是WEB，j2ee,要熟悉ssh,最好还会些JS，第二是移动端，j2me,以前很火，现在不太清楚了，第三个方向也是移动端，...
开源包xstream可以javaBean转换xml,xml转换为javaBean.
,首先确定是否是一般纳税人,如果是先到税务局办理纳税人的注销,其次看是否有税控装置,在哪办,在哪注销,
3,到税务局办理&(注:国地税都要办)
办的材料:安税控...
联系方式 公司名称: 广东东莞春发封装厂 联系人: 李先生 (业务员) 联系电话:
依赖倒置原则：具体类依赖于抽象类，而非抽象类依赖于具体类。这样做有利于一个抽象类扩展多个具体类。同时外界访问这一个类群的时候也只需要访问抽象类就可以使用类的操作...
答: java想从控制台舒服“青”这个字 import java.util.Scanner Scanner input = new S 下一句语句是什
答: 在1990年代末期，为了促进对等网络应用的发展，升阳(SUN)公司增加了一些类到Java技术中，让开发者能开发分散的实时聊天的applet和应用，这是在即时通信...
答: 还要看个人因素。两个职业么，呵呵
我目前是程序员，感觉比网络工程师累，每天作者不动，体能日益下降，十指也饱受摧残，而且程序员一定要向设计员发展，而且一般也是这样...
规模以上工业企业是指全部国有企业(在工商局的登记注册类型为"110"的企业)和当年产品销售收入500万元以上(含)的非国有工业企业。
销售额：指企业在销售商品、提供劳务及让渡资产使用权等日常活动中所形成的经济利益的总流入。税法上这一概念是不含任何税金的收入。销售额适用于制造业、商业等。
营业额会计上指的是营业收入，税法指的是应税营业收入。营业额属于含税收入，适用于饮食业、运输业、广告业、娱乐业、建筑安装业等 。
这个问题有点不知所问了。
公务员并不由单位性质决定，行政单位行政编的是公务员，但并不是说行政单位的就是公务员，事业单位里面参照管理的也是公务员。
所以你的问题只能回答为：按公务员管理的是公务员。
考虑是由于天气比较干燥和身体上火导致的，建议不要吃香辣和煎炸的食物，多喝水，多吃点水果，不能吃牛肉和海鱼。可以服用（穿心莲片，维生素b2和b6）。也可以服用一些中药，如清热解毒的。
确实没有偿还能力的，应当与贷款机构进行协商，宽展还款期间或者分期归还； 如果贷款机构起诉到法院胜诉之后，在履行期未履行法院判决，会申请法院强制执行； 法院在受理强制执行时，会依法查询贷款人名下的房产、车辆、证券和存款；贷款人名下没有可供执行的财产而又拒绝履行法院的生效判决，则有逾期还款等负面信息记录在个人的信用报告中并被限制高消费及出入境，甚至有可能会被司法拘留。
第一步：教育引导
不同年龄阶段的孩子“吮指癖”的原因不尽相同，但于力认为，如果没有什么异常的症状，应该以教育引导为首要方式，并注意经常帮孩子洗手，以防细菌入侵引起胃肠道感染。
第二步：转移注意力
比起严厉指责、打骂，转移注意力是一种明智的做法。比如，多让孩子进行动手游戏，让他双手都不得闲，或者用其他的玩具吸引他，还可以多带孩子出去游玩，让他在五彩缤纷的世界里获得知识，增长见识，逐渐忘记原来的坏习惯。对于小婴儿，还可以做个小布手套，或者用纱布缠住手指，直接防止他吃手。但是，不主张给孩子手指上“涂味”，比如黄连水、辣椒水等，以免影响孩子的胃口，黄连有清热解毒的功效，吃多了还可导致腹泻、呕吐。
合肥政务区网络广告推广网络推广哪家公司比较好 一套能在互联网上跑业务的系统，被网络营销专家赞为目前最 有效的网络推广方式！
1、搜索引擎营销：分两种SEO和PPC，即搜索引擎优化，是通过对网站结构、高质量的网站主题内容、丰富而有价值的相关性外部链接进行优化而使网站为用户及搜索引擎更加友好，以获得在搜索引擎上的优势排名为网站引入流量。
良工拥有十多位资深制冷维修工程师，十二年生产与制造经验，技术力量雄厚，配有先进的测试仪器，建有系列低温测试设备，备有充足的零部件，包括大量品牌的压缩机，冷凝器，蒸发器，水泵，膨胀阀等备品库，能为客户提供迅捷，优质的工业冷水机及模温机维修和保养。
楼主，龙德教育就挺好的，你可以去试试，我们家孩子一直在龙德教育补习的，我觉得还不错。
成人可以学爵士舞。不过对柔软度的拒绝比较大。　　不论跳什么舞，如果要跳得美，身体的柔软度必须要好，否则无法充分发挥出理应的线条美感，爵士舞也不值得注意。在展开暖身的弯曲动作必须注意，不适合在身体肌肉未几乎和暖前用弹振形式来做弯曲，否则更容易弄巧反拙，骨折肌肉。用静态方式弯曲较安全，不过也较必须耐性。柔软度的锻炼动作之幅度更不该超过疼痛的地步，肌肉有向上的感觉即可，动作(角度)保持的时间可由10馀秒至30-40秒平均，时间愈长对肌肉及关节附近的联结的组织之负荷也愈高。
正在加载...
Copyright &
Corporation, All Rights Reserved
确定举报此问题
举报原因(必选)：
广告或垃圾信息
激进时政或意识形态话题
不雅词句或人身攻击
侵犯他人隐私
其它违法和不良信息
报告，这不是个问题
报告原因(必选)：
这不是个问题
这个问题分类似乎错了
这个不是我熟悉的地区
相关问答：123456789101112131415