描述一下概念:
1. 属性与方法
属性和方法都是类的成员,用于描述类的特征,每个类都可以有若干个属性、若干个方法。
public class Sample {
}
属性用于描述可以使用值进行量化的特征,通常属性的名称会使用名词,例如:
public class Person {
String from; // 默认为null
String name; // 默认为null
int height; // 默认为0
float weight; // 默认为0.0f
}
方法用于描述动作或者行为,通常方法的名称是动词,例如:
public class Person {
void eat() {
// 东西怎么吃的?
}
void run() {
// 怎么实现跑步的?
}
}
方法的参数:参数是当执行方法时所需要的条件。
public class Sample {
void sum(int x, int y) {
}
}
当方法声明了参数后,调用该方法时,必须提供匹配数据类型、匹配数量、匹配位置的参数值,例如:
public class Test {
public static void main(String[] a) {
Sample sample = new Sample();
// sample.sum(); // 错误
// sample.sum(1234); // 错误
// sample.sum("hello"); // 错误
sample.sum(10, 20); // 正确
}
}
每一个方法都可以有返回值,如果不需要返回值,则应该声明返回类型为void,如果需要,则声明为对应的类型,且在方法的最后,应该使用return语句返回对应类型的数据,例如:
public class Sample {
int sum(int x, int y) {
return x + y;
}
}
当调用有返回值的方法时,可以获取其返回值,也可以不获取,例如:
public class Test {
public static void main(String[] args) {
Sample sample = new Sample();
sample.sum(10, 15); // 仅调用,不获取值
int a = sample.sum(3, 7); // 调用,且获取值
}
}
对于声明为void返回值的方法,也可以使用return语句,但是,return关键字后不可以有任何值,例如:
public class Sample {
void test() {
return;
// System.out.println(); // 无法被执行的语句,错误
}
}
不管返回值是什么类型,return都应该是方法的最后一条有效语句。
为了便于开发,方法允许重载(Overload),即:在同一个类中允许存在若干个名称相同的方法,但是,这些方法的参数列表必须不同,例如:
public class Sample {
void run() {}
void run(int x) {}
void run(String str) {}
void run(String str1, String str2, int x) {}
void run(int x, String str2, String str1) {}
void run(String str1, int x, String str2) {}
}
参数列表的区别表现为:数量、数据类型、顺序
【测试题】
public class Test1 {
public static void add1(int i) {
i++;
}
public static void add2(int[] arr) {
arr[0]++;
}
public static void main(String[] args) {
int x = 10;
add1(x);
System.out.println("x=" + x); // 10
int[] array = { 9, 5, 2, 7 };
add2(array);
System.out.println("array[0]=" + array[0]); // 10
}
}
public class Test2 {
public static void main(String[] args) {
int x = 10;
int y;
y = x;
y = 15;
System.out.println("x=" + x); // 10
System.out.println("y=" + y); // 15
int[] arr1 = { 9, 5, 2, 7 };
int[] arr2;
arr2 = arr1;
arr2[0] = 15;
System.out.println("arr1[0]=" + arr1[0]); // 15
System.out.println("arr2[0]=" + arr2[0]); // 15
}
}
2. 构造方法
构造方法是一类特殊的方法,其特征是:
1) 构造方法不允许声明返回值类型,即连void都不可以
2) 构造方法的名称必须与类的名称完全相同
如果类中没有显式的声明构造方法,则编译器会自动的添加公有的、无参数的构造方法,例如以下2段代码是等效的:
public class Person {
}
public class Person {
public Person() {
super();
}
}
构造方法用于创建类的对象,例如:
public class Test {
public static void main(String[] args) {
Person p = new Person();
}
}
如果开发者显式的声明了构造方法,则编译器不会再自动添加构造方法。
构造方法可以用于创建对象时直接指定对象的某些属性值,例如没有构造方法时:
public class Person {
public String name;
public int age;
}
public class Test {
public static void main(String[] args) {
Person p = new Person();
p.name = "Jack";
p.age = 18;
}
}
如果指定了构造方法:
public class Person {
public String name;
public int age;
public Person(String personName, int personAge) {
name = personName;
age = personAge;
}
}
public class Test {
public static void main(String[] args) {
Person p = new Person("Jack", 18);
}
}
构造方法也可以重载,例如:
public class Person {
public String name;
public int age;
public Person() {
}
public Person(String personName, int personAge) {
name = personName;
age = personAge;
}
}
3. this、super关键字
this表示当前类的对象,super表示当前类的父类的对象。
public class Person extends Object {
public String name;
public Person() {
this("unknown"); // 调用自身的另一个构造方法
}
public Person(String name) {
super(); // 调用父类的构造方法
this.name = name;
}
public String toString() {
return null;
}
public void test1() {
super.toString();
}
public void test2() {
toString();
}
}
public class Test {
public static void main(String[] args) {
Person jack = new Person("Jack");
jack.name = "Jackson";
// Person.name = "???"; // 普通属性不可以这样调用
Person mike = new Person("Mike");
}
}
4. 内部类
内部类就是声明在其它类的内部的类,主要有:
1) 成员内部类:以类的成员的形式出现的内部类,例如:
public class Sample {
public void run() {
InnerClass ic = new InnerClass();
}
public class InnerClass {
System.out.println(x);
}
public int x;
}
成员内部类可以使用任何访问权限修饰符。
内部类可以访问外部类的任意成员,包括私有的。
在没有创建外部类的对象之前,不可以直接创建内部类的对象。
2) 局部内部类:定义在方法的内部的内部类。
public class Sample {
public z = 10;
public void run() {
int x = 10;
final int y = 10;
class InnerClass {
void test() {
// System.out.println(x); // 错误
System.out.println(y); // 正确
System.out.println(z); // 正确
}
}
InnerClass ic = new InnerClass();
}
}
局部内部类不可以使用任何访问权限修饰符。
使用局部内部类时,需要注意代码的先后顺序。
在局部内部类中,不可以直接访问局部变量,如果一定需要访问,可以使用final修饰该局部变量,或者将局部变量声明为全局变量(类的属性)。
3) 静态成员内部类:静态内部类是使用static修饰的成员内部类,例如:
public class Sample {
public static int x = 10;
public static class InnerClass {
public void run() {
System.out.println(x);
}
}
}
静态内部类不可以访问外部类中非静态的成员。
静态内部类可以直接创建对象,而不需要依赖于外部类的对象。
4) 匿名内部类:直接创建已知的类的子类对象,或者已知的接口的实现类对象,而创建时,并不体现子类/实现类的名称,即创建出来的对象的类名是未知的,例如:
public class Sample {
protected void onCreate() {
new OnClickListener() {
@Override
public void onClick(View v) {
}
};
}
}
Logcat日志级别
---------------------------------------
v -> verbose -> 观察 -> 黑色
d -> debug -> 调试 -> 绿色
i -> info -> 信息 -> 蓝色
w -> warn -> 警告 -> 橙色
e -> error -> 错误 -> 红色
在BaseAdapter中getView()方法的convertView重复使用
----------------------------------------
当ListView需要显示列表项时,会调用Adapter中的getView()方法。在第一次显示之后,如果滑动ListView,则某些列表项会滑出屏幕范围,而一些新的列表项会进入屏幕范围,此时,ListView会将滑出屏幕的列表项的View对象用于调用显示新列表项的getView()方法,表现为getView()方法的第2个参数convertView。
基于ListView这样的工作机制,可以保证convertView在第1次显示时均为null,但是,滑动屏幕之后,不为null,则convertView对象的数量是该ListView可以显示的列表项数量的最大值。
在编程时,应该对convertView是否为null进行判断,如果为null,则需要根据xml模板加载得到,如果不为null,则直接使用即可。convertView就是模板的View对象。