数组
数组是对象,数组中的每个元素相当于该对象的成员变量。
数组的声明:
public class Test{
public static void main(String[] args){
int[] arr01 = new int[10]; //声明数组并分配空间,默认初始化
arr01.length; //arr01数组的长度
String[] arr02; //或String arr02[];
arr02 = new String[5]; //默认初始化,int型默认:0;boolean型默认:false;String型默认:null。
User[] arr03 = new User[3];
arr03[0] = new User(1001,"零");//动态初始化
arr03[1] = new User(1001,"一");
arr03[2] = new User(1001,"二");
for (int i = 0; i < arr03.length; i++){
System.out.println(arr03[i].getName());
int[] a = {2,3,4,5,6}; //静态初始化
User[3] b = {
new User(123,"一一");
new User(234,"二一");
new User(345,"三一");
}; //静态初始化
}
}
class User {
private int id;
private String name;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Test(int id, String name) {
super();
this.id = id;
this.name = name;
}
}
for each循环
用于读取数组元素,不能修改元素的值。
int[] a = new int[4];
for (int i = 0; i < a.length; i++){
a[i] = 100 * i;
}//初始化
for(int m : a){
System.out.println(m);
} //foreach循环,输出 0 100 200 300
抽象方法和抽象类
抽象方法:使用abstract修饰的方法,没有方法体,只有声明。
抽象类:包含抽象方法的类(只能定义成抽象类);里面也可以定义普通方法;只能用来被继承,不能用new来实例化;抽象方法必须被子类实现。
package cn.learning;
/**
* 抽象类的意义在于:为子类提供统一的、规范的摸板。
* @author 86138
*
*/
public abstract class test {
abstract public void shout(); //没有实现
public void run() {
System.out.println("跑");
}
}
class Dog extends test{
@Override
public void shout() { //子类必须实现
System.out.println("汪汪汪");
}
}
接口
接口:比“抽象类”更“抽象” 的“抽象类”。
声明格式:
[访问修饰符] interface 接口名 [extends 父接口1,父接口2...] { //可以多继承
常量定义;
方法定义;
}
package cn.learning;
interface A{
void testa();
}
interface B{
void testb();
}
public interface testInterface extends A,B { //只能是public或默认,可继承多个接口
/*public static final*/ int A = 100; //只能是常量,只能public static final修饰,不写也是
/*public abstract*/ void test01(); //方法只能是public abstract修饰,不写也是
}
class myTest implements testInterface{ //也可以implements多个接口
@Override
public void test01() {
System.out.println(A);
System.out.println("FUCK");
}
@Override
public void testa() {
System.out.println("SUCK");
}
@Override
public void testb() {
System.out.println("CRAP");
}
}
内部类
非静态内部类
1、非静态内部类可以直接访问外部类的成员,外部类不能直接访问非静态内部类成员;
2、非静态内部类不能有静态方法、静态属性、静态语块。
package cn.learning;
public class TestInnerClass {
public static void main(String[] args) {
Outer.Inner inner = new Outer().new Inner();//创建内部类对象
inner.show();
}
}
class Outer{ //外部类不能直接访问非静态内部类
private int age = 10;
public void testOuter() {
}
class Inner{ //有独立的class文件
int age = 20;
public void show() {
int age = 30;
//调用不同age
System.out.println("外部age:" + Outer.this.age);//可调用外部类的属性、方法
System.out.println("内部age:" + this.age);
System.out.println("局部age:" + age);
}
}
}
静态内部类
package cn.learning;
public class TestStaticInnerClass {
public static void main(String[] args) {
Outer2.Inner2 inner = new Outer2.Inner2();//创造静态内部类对象
}
}
class Outer2{
static class Inner2{
//...
}
}
匿名内部类
适合定义只用一次的类。
语法:
new 父类构造器(实参类表) \实现接口 (){
//匿名内部类类体
}
package cn.learning;
public class Test01 {
public static void test01(AA a) {
System.out.println("#############");
a.aa();
}
public static void main(String[] args) {
Test01.test01(new AA() {
@Override
public void aa() {
System.out.println("TestTTTTT");
} //匿名内部类
});
} //
}
interface AA{
void aa();
}
局部内部类
定义在方法里的内部类。