********************2014、11、12********************
1、Android 之 fill_parent 、wrap_content 、match_parent属性
fill_parent 设置一个顶部布局或控件为fill_parent将强制性让它布满整个屏幕。
wrap_content 设置一个视图的尺寸为wrap_content将强制性地使视图扩展以显示全部内容
2、在程序中输出日志, 使用 android.util.Log 类.
该类提供了若干静态方法
Log.v(String tag, String msg);
Log.d(String tag, String msg);
Log.i(String tag, String msg);
Log.w(String tag, String msg);
Log.e(String tag, String msg);
分别对应 Verbose, Debug, Info, Warning,Error.
tag是一个标识,可以是任意字符串,通常可以使用类名+方法名, 主要是用来在查看日志时提供一个筛选条件.
程序运行后 并不会在 ide的控制台内输出任何信息.
如果要后查看日志 请使用
adb logcat
3、command + shift + f 格式化代码 ，option + / 提示，option + 上下键 移动某行代码，option + command + 上下键，option + command + s 弹出菜单功能页，Ctrl+1 快速修复(最经典的快捷键,就不用多说了)
4、layout文件夹里新建xml命名：必须都是小写
5、完成A跳转到B操作：要在AndroidMainifest.xml的文件里面
<activity
android:name="com.example.sample1.新加入的类名字”
android:label=“页面的标题” >
</activity>
AndroidManifest.xml是Android应用程序中最重要的文件之一。它是Android程序的全局配置文件，是每个 android程序中必须的文件。它位于我们开发的应用程序的根目录下，描述了package中的全局数据，包括package中暴露的组件 （activities, services, 等等），以及他们各自的实现类，各种能被处理的数据和启动位置等重要信息。
********************2014、11、13********************
1、布局Layout管理http://www.cnblogs.com/mengdd/archive/2012/12/19/2825382.html
布局即是指Activity中组件的呈现方式，即组件大小、间距和对齐方式等。
Android提供了两种创建布局的方式：
1.在XML配置文件中声明（推荐）。
2.在程序中通过代码直接实例化布局及其组件。
在Android中常见的布局方式：
线性布局（LinearLayout）：按照垂直或者水平方向布局组件。
帧布局（FrameLayout）：组件从屏幕的左上角坐标布局组件。
表格布局（TableLayout）：按照行列方式布局组件。
相对布局（RelativeLayout）：相对其他组件的布局方式。
绝对布局（AbsoluteLayout）：按照绝对坐标来布局组件。（已废）。
2、一个ListView通常有两个职责。
（1）将数据填充到布局。
（2）处理用户的选择点击等操作。
第一点很好理解，ListView就是实现这个功能的。第二点也不难做到，在后面的学习中读者会发现，这非常简单。
一个ListView的创建需要3个元素。
（1）ListView中的每一列的View。
（2）填入View的数据或者图片等。
（3）连接数据与ListView的适配器。
3、关于List<E>的用法
List l=new List();
现在这样，如果你想放得是User类，就这样new:
List <User> l=new List <User>();
这样编译器就可以帮你监督，如果你往里面放其他类对象，就会报错咯。
当然好处就是你拿出来就是User类对象，不用再强制转换了。比如过去：
User u=(User)l.get(1);
现在就可以：
User u=l.get(1);
4、ArrayList && HashMap 的使用
ArrayList<HashMap<String,String>> list=new ArrayList<HashMap<String,String>>();
HashMap<String,String> map1= new HashMap<String,String>();
HashMap<String,String> map2= new HashMap<String,String>();
HashMap<String,String> map3= new HashMap<String,String>();
map1.put("user", "zhang");
map1.put("id", "192.168.0.0");
map2.put("user", "wang");
map2.put("id", "192.168.0.1");
list.add(map1);
list.add(map2);
list.add(map3);
Log.v("ArrayList==HashMap===:", list.toString());
5、/*
* AlertDialog 的使用
*/
Builder alertDialog = new AlertDialog.Builder(this);
alertDialog.setTitle("标题");// 设置标题
alertDialog.setMessage("一个消息框");// 设置消息
alertDialog.setPositiveButton("确定", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
// toast 的用法
Toast.makeText(getApplicationContext(), "你选择了确定",
Toast.LENGTH_SHORT).show();
}
});
alertDialog.show();
6、Button 的使用: 通过具体的id 找到某个控件
// 给按钮加上点击事件
clickMeButton.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
Log.v("click", "=======clickButton=======");
// 跳转到SecondActivity页面
Intent intent = new Intent();
intent.setClass(MainActivity.this, SecondActivity.class);
startActivity(intent);
}
});
7、dp是虚拟像素，在不同的像素密度的设备上会自动适配，比如:
在320x480分辨率，像素密度为160,1dp=1px
在480x800分辨率，像素密度为240,1dp=1.5px
计算公式:1dp*像素密度/160 = 实际像素数
px（像素）：屏幕上的点。
dp（与密度无关的像素）：一种基于屏幕密度的抽象单位。在每英寸160点的显示器上，1dp = 1px。
尽量使用dp作为空间大小单位，sp作为和文字相关大小单位
********************2014、11、14********************
匿名内部类也就是没有名字的内部类
正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写
但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口(只要一个类是抽象的或是一个接口，那么其子类中的方法都可以使用匿名内部类来实现最常用的情况就是在多线程的实现上，因为要实现多线程必须继承Thread类或是继承Runnable接口)
sample1：Thread t = new Thread() {
public void run() {
for (int i = 1; i <= 5; i++) {
System.out.print(i + " ");
}
}
};
t.start();
sample2：Runnable r = new Runnable() {
public void run() {
for (int i = 1; i <= 5; i++) {
System.out.print(i + " ");
}
}
};
Thread t = new Thread(r);
t.start();
2、Android中常常使用shape来定义控件的一些显示属性(比如：button，cell的backround)
http://kofi1122.blog.51cto.com/2815761/521605
<shape>
<!-- 实心 -->
<solid android:color="#ff9d77"/>
<!-- 渐变 -->
<gradient
android:startColor="#ff8c00"
android:endColor="#FFFFFF"
android:angle="270" />
<!-- 描边 -->
<stroke
android:width="2dp"
android:color="#dcdcdc" />
<!-- 圆角 -->
<corners
android:radius="2dp" />
<padding
android:left="10dp"
android:top="10dp"
android:right="10dp"
android:bottom="10dp" />
</shape>
solid：实心，就是填充的意思
android:color指定填充的颜色
gradient：渐变
android:startColor和android:endColor分别为起始和结束颜色，ndroid:angle是渐变角度，必须为45的整数倍。
另外渐变默认的模式为android:type="linear"，即线性渐变，可以指定渐变为径向渐变，android:type="radial"，径向渐变需要指定半径android:gradientRadius="50"。
stroke：描边
android:width="2dp" 描边的宽度，android:color 描边的颜色。
我们还可以把描边弄成虚线的形式，设置方式为：
android:dashWidth="5dp"
android:dashGap="3dp"
其中android:dashWidth表示'-'这样一个横线的宽度，android:dashGap表示之间隔开的距离。
corners：圆角
android:radius为角的弧度，值越大角越圆。
我们还可以把四个角设定成不同的角度，方法为：
<corners
android:topRightRadius="20dp" 右上角
android:bottomLeftRadius="20dp" 右下角
android:topLeftRadius="1dp" 左上角
android:bottomRightRadius="0dp" 左下角
/>
这里有个地方需要注意，bottomLeftRadius是右下角，而不是左下角，这个有点郁闷，不过不影响使用，记得别搞错了就行。
还有网上看到有人说设置成0dp无效，不过我在测试中发现是可以的，我用的是2.2，可能修复了这个问题吧，如果无效的话那就只能设成1dp了。
padding：间隔
这个就不用多说了，XML布局文件中经常用到。
大体的就是这样，以下是一个使用的具体示例：用在Selector中作为Button的背景，分别定义了按钮的一般状态、获得焦点状态和按下时的状态，具体代码如下：
使用地方：
<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="TestShapeButton"
android:background="@drawable/button_selector"
/>
3、SharedPreferences的使用
存：SharedPreferences settings = getSharedPreferences("SharedInstance", 0);
settings.edit().putString("name", editView.getText().toString()).commit();
取： //获取一个 SharedPreferences 对象
SharedPreferences settings = getSharedPreferences("SharedInstance", 0);
//取出保存的NAME，取出改字段名的值，不存在则创建默认为空
String name = settings.getString("name", "");
********************2014、11、17********************
1、http://www.blogjava.net/action/articles/17339.html 快捷键大全
2、dp、sp和px的区别
看到有很多网友不太理解dp、sp和px的区别：现在这里介绍一下dp和sp。dp也就是dip。这个和sp基本类似。如果设置表示长度、高度等属性时可 以使用dp 或sp。但如果设置字体，需要使用sp。dp是与密度无关，sp除了与密度无关外，还与scale无关。如果屏幕密度为160，这时dp和sp和px是一 样的。1dp=1sp=1px，但如果使用px作单位，如果屏幕大小不变（假设还是3.2寸），而屏幕密度变成了320。那么原来TextView的宽度 设成160px，在密度为320的3.2寸屏幕里看要比在密度为160的3.2寸屏幕上看短了一半。但如果设置成160dp或160sp的话。系统会自动 将width属性值设置成320px的。也就是160 * 320 / 160。其中320 / 160可称为密度比例因子。也就是说，如果使用dp和sp，系统会根据屏幕密度的变化自动进行转换。
3、/*
* checkBox的使用
*/
CheckBox checkBox1 = (CheckBox)findViewById(R.id.checkBox1);
checkBox1.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
@Override
public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
// TODO Auto-generated method stub
if(isChecked){
Log.v("CheckBox","你选择了-" + buttonView.getText());
}else{
Log.v("CheckBox","你取消选择了-"+ buttonView.getText());
}
}
});
4、 /*
* <!-- RadioGroup的使用 -->
*/
RadioGroup radioGroup = (RadioGroup) findViewById(R.id.radioGroup);
radioGroup.setOnCheckedChangeListener(new OnCheckedChangeListener() {
@Override
public void onCheckedChanged(RadioGroup group, int checkedId) {
int radioButtonId = group.getCheckedRadioButtonId();
Log.v("RadioGroup", "onCheckedChanged==id=" + checkedId
+ radioButtonId);
// 根据ID获取RadioButton的实例
RadioButton rb = (RadioButton) SecondActivity.this
.findViewById(radioButtonId);
// 更新文本内容，以符合选中项
textView1.setText("您的性别是：" + rb.getText());
}
});
5、 /*
* Bundle的使用
*/
Bundle bundle = new Bundle();
bundle.putString("city", "上海");
bundle.putString("name", "狗子");
bundle.putString("age", "12");
bundle.putString("gender", "男");
String name = bundle.getString("name");
Log.v("Bundle","bundle.string="+ bundle.toString()+"名字："+name);
//bundle.string=Bundle[{gender=男, age=12, city=上海, name=狗子}]名字：狗子
// 相对于给定ID控件
android:layout_above 将该控件的底部置于给定ID的控件之上;
android:layout_below 将该控件的底部置于给定ID的控件之下;
android:layout_toLeftOf 将该控件的右边缘与给定ID的控件左边缘对齐;
android:layout_toRightOf 将该控件的左边缘与给定ID的控件右边缘对齐;
android:layout_alignBaseline 将该控件的baseline与给定ID的baseline对齐;
android:layout_alignTop 将该控件的顶部边缘与给定ID的顶部边缘对齐;
android:layout_alignBottom 将该控件的底部边缘与给定ID的底部边缘对齐;
android:layout_alignLeft 将该控件的左边缘与给定ID的左边缘对齐;
android:layout_alignRight 将该控件的右边缘与给定ID的右边缘对齐;
// 相对于父组件
android:layout_alignParentTop 如果为true,将该控件的顶部与其父控件的顶部对齐;
android:layout_alignParentBottom 如果为true,将该控件的底部与其父控件的底部对齐;
android:layout_alignParentLeft 如果为true,将该控件的左部与其父控件的左部对齐;
android:layout_alignParentRight 如果为true,将该控件的右部与其父控件的右部对齐;
// 居中
android:layout_centerHorizontal 如果为true,将该控件的置于水平居中;
android:layout_centerVertical 如果为true,将该控件的置于垂直居中;
android:layout_centerInParent 如果为true,将该控件的置于父控件的中央;
// 指定移动像素
android:layout_marginTop 上偏移的值;
android:layout_marginBottom 下偏移的值;
android:layout_marginLeft 左偏移的值;
android:layout_marginRight 右偏移的值;
********************2014、11、18********************
1、下拉列表框 Spinner的使用
myTextView = (TextView) findViewById(R.id.TextView_city);
mySpinner = (Spinner) findViewById(R.id.Spinner_city);
adapter = new ArrayAdapter<String>(this,
android.R.layout.simple_spinner_item, citys);
// 为适配器设置下拉列表下拉时的菜单样式。
adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
// 将适配器添加到下拉列表上
mySpinner.setAdapter(adapter);
mySpinner.setOnItemSelectedListener(new OnItemSelectedListener() {
@Override
public void onItemSelected(AdapterView<?> parent, View view,
int position, long id) {
// TODO Auto-generated method stub
myTextView.setText("您的选择是：" + adapter.getItem(position));
}
@Override
public void onNothingSelected(AdapterView<?> parent) {
// TODO Auto-generated method stub
// myTextView.setText("NONE");
// parent.setVisibility(View.VISIBLE);
}
});
我们会用到一些内部类和匿名类。当在匿名类中用this时，这个this则指的是匿名类或内部类本身。这时如果我们要使用外部类的方法和变量的话，则应该加上外部类的类名。
3、GridView 使用方式
GridView gridView = (GridView) findViewById(R.id.gridview);
gridView.setAdapter(new ImageAdapter(this));
gridView.setOnItemClickListener(new OnItemClickListener() {
@Override
public void onItemClick(AdapterView<?> parent, View view,
int position, long id) {
// TODO Auto-generated method stub
Toast.makeText(GridViewActivity.this, mThumbIds[position], Toast.LENGTH_LONG).show();
}
});
4、代码法设置背景颜色
ImageView设置背景颜色
ImageView.setBackgroundColor(android.graphics.Color.parseColor("#ffffff"));
ImageView.setBackgroundColor(Color.RED);
ImageView.setBackgroundColor(Color.rgb(255, 0, 0));
BroadcastReceiver用于接收程序（包括用户开发的程序和系统内建的程序）所发出的Broadcast Intent，与应用程序启动Activity、Service相同的是，程序启动BroadcastReceiver也只需要两步。
1）创建需要启动的BroadcastReceiver的Intent。
2）调用Context的sendBroadcast()或sendOrderedBroadcast()方法来启动指定BroadcastReceiver。
①内部类的方式
{
//1、注册
myBroadCast = new MyBroadCast();
IntentFilter filter = new IntentFilter();
filter.addAction(ACTION_INTENT_TEST);
registerReceiver(myBroadCast, filter);
}
@Override
protected void onDestroy() {
super.onDestroy();
//2、取消注册
unregisterReceiver(myBroadCast);
}
//3、内部类实现
public class MyBroadCast extends BroadcastReceiver {
public MyBroadCast() {
Log.v("BROADCAST_TAG", "myBroadCast");
}
@Override
public void onReceive(Context context, Intent intent) {
// TODO 处理接收到得广播
Log.v("BROADCAST_TAG", "onReceive===1111111");
}
}
//4、发送广播
Intent intent = new Intent(ThirdActivity.ACTION_INTENT_TEST);
sendBroadcast(intent);
********************2014、11、19********************
1、fragment的使用
Fragment必须是依存与Activity而存在的
http://blog.csdn.net/lmj623565791/article/details/37970961
找fragment的方法：
LeftFragment fragment = (LeftFragment) getFragmentManager().findFragmentById(R.id.left_fragment);
2、Java关键字final、static使用总结
一、final
根据程序上下文环境，Java关键字final有“这是无法改变的”或者“终态的”含义，它可以修饰非抽象类、非抽象类成员方法和变量。你可能出于两种理解而需要阻止改变：设计或效率。
final类不能被继承，没有子类，final类中的方法默认是final的。
final方法不能被子类的方法覆盖，但可以被继承。
final成员变量表示常量，只能被赋值一次，赋值后值不再改变。
final不能用于修饰构造方法。
注意：父类的private成员方法是不能被子类方法覆盖的，因此private类型的方法默认是final类型的。
1、final类
final类不能被继承，因此final类的成员方法没有机会被覆盖，默认都是final的。在设计类时候，如果这个类不需要有子类，类的实现细节不允许改变，并且确信这个类不会载被扩展，那么就设计为final类。
2、final方法
如果一个类不允许其子类覆盖某个方法，则可以把这个方法声明为final方法。
使用final方法的原因有二：
第一、把方法锁定，防止任何继承类修改它的意义和实现。
第二、高效。编译器在遇到调用final方法时候会转入内嵌机制，大大提高执行效率。
例如：
|
public class Test1 {
public static void main(String[] args) { // TODO 自动生成方法存根 }
public void f1() { System.out.println("f1"); } //无法被子类覆盖的方法 public final void f2() { System.out.println("f2"); }
public void f3() { System.out.println("f3"); }
private void f4() { System.out.println("f4"); } }
public class Test2 extends Test1 {
public void f1(){ System.out.println("Test1父类方法f1被覆盖!"); }
public static void main(String[] args) { Test2 t=new Test2(); t.f1(); t.f2(); //调用从父类继承过来的final方法 t.f3(); //调用从父类继承过来的方法 //t.f4(); //调用失败，无法从父类继承获得
} } |
3、final变量（常量）
用final修饰的成员变量表示常量，值一旦给定就无法改变！
final修饰的变量有三种：静态变量、实例变量和局部变量，分别表示三种类型的常量。
从下面的例子中可以看出，一旦给final变量初值后，值就不能再改变了。
另外，final变量定义的时候，可以先声明，而不给初值，这中变量也称为final空白，无论什么情况，编译器都确保空白final在使用之前必须被初始化。但是，final空白在final关键字final的使用上提供了更大的灵活性，为此，一个类中的final数据成员就可以实现依对象而有所不同，却有保持其恒定不变的特征。
|
package org.leizhimin;
public class Test3 { private final String S="final实例变量S"; private final int A=100; public final int B=90;
public static final int C=80; private static final int D=70;
public final int E; //final空白,必须在初始化对象的时候赋初值
public Test3(int x){ E=x; }
/** * @param args */ public static void main(String[] args) { Test3 t=new Test3(2); //t.A=101; //出错,final变量的值一旦给定就无法改变 //t.B=91; //出错,final变量的值一旦给定就无法改变 //t.C=81; //出错,final变量的值一旦给定就无法改变 //t.D=71; //出错,final变量的值一旦给定就无法改变
System.out.println(t.A); System.out.println(t.B); System.out.println(t.C); //不推荐用对象方式访问静态字段 System.out.println(t.D); //不推荐用对象方式访问静态字段 System.out.println(Test3.C); System.out.println(Test3.D); //System.out.println(Test3.E); //出错,因为E为final空白,依据不同对象值有所不同. System.out.println(t.E);
Test3 t1=new Test3(3); System.out.println(t1.E); //final空白变量E依据对象的不同而不同 }
private void test(){ System.out.println(new Test3(1).A); System.out.println(Test3.C); System.out.println(Test3.D); }
public void test2(){ final int a; //final空白,在需要的时候才赋值 final int b=4; //局部常量--final用于局部变量的情形 final int c; //final空白,一直没有给赋值. a=3; //a=4; 出错,已经给赋过值了. //b=2; 出错,已经给赋过值了. } } |
4、final参数
当函数参数为final类型时，你可以读取使用该参数，但是无法改变该参数的值。
|
public class Test4 { public static void main(String[] args) { new Test4().f1(2); }
public void f1(final int i){ //i++; //i是final类型的,值不允许改变的. System.out.print(i); } }
|
二、static
static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态static代码块，但是Java语言中没有全局变量的概念。
被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。
用public修饰的static成员变量和成员方法本质是全局变量和全局方法，当声明它类的对象市，不生成static变量的副本，而是类的所有实例共享同一个static变量。
static变量前可以有private修饰，表示这个变量可以在类的静态代码块中，或者类的其他静态成员方法中使用（当然也可以在非静态成员方法中使用--废话），但是不能在其他类中通过类名来直接引用，这一点很重要。实际上你需要搞明白，private是访问权限限定，static表示不要实例化就可以使用，这样就容易理解多了。static前面加上其它访问权限关键字的效果也以此类推。
static修饰的成员变量和成员方法习惯上称为静态变量和静态方法，可以直接通过类名来访问，访问语法为：
类名.静态方法名(参数列表...)
类名.静态变量名
用static修饰的代码块表示静态代码块，当Java虚拟机（JVM）加载类时，就会执行该代码块（用处非常大，呵呵）。
1、static变量
按照是否静态的对类成员变量进行分类可分两种：一种是被static修饰的变量，叫静态变量或类变量；另一种是没有被static修饰的变量，叫实例变量。两者的区别是：
对于静态变量在内存中只有一个拷贝（节省内存），JVM只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配，可用类名直接访问（方便），当然也可以通过对象来访问（但是这是不推荐的）。
对于实例变量，没创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响（灵活）。
2、静态方法
静态方法可以直接通过类名调用，任何的实例也都可以调用，因此静态方法中不能用this和super关键字，不能直接访问所属类的实例变量和实例方法(就是不带static的成员变量和成员成员方法)，只能访问所属类的静态成员变量和成员方法。因为实例成员与特定的对象关联！这个需要去理解，想明白其中的道理，不是记忆！！！
因为static方法独立于任何实例，因此static方法必须被实现，而不能是抽象的abstract。
3、static代码块
static代码块也叫静态代码块，是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。例如：
|
public class Test5 { private static int a; private int b;
static{ Test5.a=3; System.out.println(a); Test5 t=new Test5(); t.f(); t.b=1000; System.out.println(t.b); } static{ Test5.a=4; System.out.println(a); } public static void main(String[] args) { // TODO 自动生成方法存根 } static{ Test5.a=5; System.out.println(a); } public void f(){ System.out.println("hhahhahah"); } } |
运行结果：
3
hhahhahah
1000
4
5
利用静态代码块可以对一些static变量进行赋值，最后再看一眼这些例子，都一个static的main方法，这样JVM在运行main方法的时候可以直接调用而不用创建实例。
4、static和final一块用表示什么
static final用来修饰成员变量和成员方法，可简单理解为“全局常量”！
对于变量，表示一旦给值就不可修改，并且通过类名可以访问。
对于方法，表示不可覆盖，并且可以通过类名直接访问。
【自己补充的】5、static还可以修饰内部类，普通类是不允许声明为静态的，只有内部类才可以。被static修饰的内部类可以直接作为一个普通类来使用，而不需实例化一个外部类
例如有个类
class TestInner{
static class StaticInnerClass{
}
class InnerClass{
}
}
那么在main中实例化StaticInnerClass的代码是这样写
new TestInner.StaticInnerClass();
而实例化InnerClass则必须写成
TestInner testInner = new TestInner();
testInner.new InnerClass();
所以要注意了哦！
而且呢，在InnerClass里面已经无法再声明static innner class了，因为The member type inner cannot be declared static; static types can only be declared in static or top level types
*********************11.28*********************
抽象类 abstract class
包含抽象方法的类，叫抽象类。而抽象的概念就是抽象出共同属性：成员变量和方法。所以抽象类可以有private等多种权限的成员变量和非abstract的成员方法。当然抽象方法是一定要有的。
抽象类是用于单一继承的，不能实例化。而继承类一定要实现抽象方法，因为抽象方法在抽象类里是没有实现行为的，访问权限只能是public。而非抽象方法则可以赋予方法的默认行为，访问权限可以多种，但需要考虑非抽象方法是否需要被继承类访问。
接口 interface
接口，用于多重继承，也不能实例化。只能包含static final的成员变量，不过在interface中一般不定义成员变量。而成员方法在接口里只能是抽象方法，访问权限只能是public。
http://android.blog.51cto.com/268543/385282/
mac 下Android studio快捷键的使用
1、command + o 查找某个类
2、command + d 复制一行
3、command + x 删除一行
4、command + e 查找最近编辑的类
5、option + 上下键 挪动代码
6、control + t 重新命名
7、command＋Alt＋T可以把代码包在一块内，例如try/catch
http://blog.csdn.net/harvic880925/article/details/17263275