内部类(补充)
局部内部类
如果在外界定义会检测不到你所定义的局部内部类,直接报错.
public class Main {
public static void print(int age,int b){
class person{
int age;
public person(int age) {
this.age = age;
}
void show(){
System.out.println("内部类输出: "+age+"\t"+b); //调用外部方法的变量
}
}
person a=new person(age);
a.show();
System.out.println("方法输出 :"+b);
}
public static void main(String[] args) {
print(6,7);
}
}运行结果
匿名内部类
匿名内部类无法创建多个对象,因为他没有名字,它既可以写在成员位置,也可以写在局部位置.
这个匿名内部类的作用主要是替代那些只出现一次的类,当类只出现一次时我们只需要把他定义成匿名内部类就好,这样就可以不用去重新创建类了.一般当方法的参数是接口或者类时使用.
new Inter(){
public void show(){
}
}
//以上代码总体上来说是一个对象
//这一段代码完成了三个功能:
//实现或继承关系
//方法的重写
//创建对象
//new //用空参构造创建匿名内部类的对象
//Inter //是已经定义好的一个接口或一个类
//这是一个匿名内部类(实现Inter接口或继承Inter类)
//{ //类的开始
// public void show(){
// }
//} //类的结束
//以上是你创建的类的内容样例:
public interface Animal {
public void eat();
}public abstract class Swim {
public abstract void swim();
}public class Main {
public static void main(String[] args) {
method(
new Swim(){
@Override
public void swim() {
System.out.println("类的实现方法");
}
}
);
method1(
new Animal(){
@Override
public void eat() {
System.out.println("接口的实现方法");
}
}
);
}
public static void method(Swim a){ //多态
a.swim();
}
public static void method1(Animal a){ //多态
a.eat();
}
}正则表达式
匹配一个字符
public class Main {
public static void main(String[] args) {
System.out.println("jjm".matches("[j-m][j-m][j-m]"));
System.out.println("jjm".matches("[j-m]"));
}
}运行结果
注意:
在使用正则表达式的时候如果出现了\那么要在\前加上\.( '\' 表示转义字符,所以"\\d"才表示一个数字).
匹配多个字符
以上都是匹配只出现一次的情况的,那么如果出现多次呢?
public class Main {
public static void main(String[] args) {
System.out.println("jjm".matches("\\w{3}"));
System.out.println("jjm".matches("\\w{2}"));
System.out.println("jjm".matches("\\w +"));
}
}运行结果
泛型
为什么要用到泛型?
public class Student {
String name;
int age;
public Student (){
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}import java.util.ArrayList;
import java.util.Iterator;
public class Main {
public static void main(String[] args) {
//创建链表
ArrayList list=new ArrayList(); //集合的基本使用
//添加数据
list.add(123);
list.add("add");
list.add(new Student("jjm",19));
//遍历集合里的每一个元素
Iterator it=list.iterator();
while(it.hasNext()){
//Student a=(Student )it.next(); 这时我们用什么来报存集合里的元素呢??
System.out.println();
}
}
}这时我们用什么来报存集合里的元素呢?好像什么都不太适合.
所以泛型出现了,泛型的本质是为了将类型参数化， 也就是说在泛型使用过程中，数据类型被设置为一个参数，在使用时再从外部传入一个数据类型；而一旦传入了具体的数据类型后，传入变量（实参）的数据类型如果不匹配，编译器就会直接报错。
如果我们用泛型来规范数据的类型就会避免以上可能出现的错误.
泛型的定义: <类型>
使用的地方:类的后面(泛型类),方法上面(泛型方法),接口后面(泛型接口).
泛型类
泛型方法
泛型接口
注意:
1.泛型中不能写基本类型数据.
2.指定泛型的具体类型后,传递类型时可以传递该类型或其子类类型.
3.如果不写泛型,类型默认为Object.
我们在程序中加入泛型
import java.util.ArrayList;
import java.util.Iterator;
public class Main {
public static void main(String[] args) {
//创建链表
ArrayList<String> list=new ArrayList();
//添加数据
list.add("123");
list.add("add");
list.add("jjm");
//遍历集合里的每一个元素
Iterator<String> it=list.iterator();
while(it.hasNext()){
String a=it.next();
System.out.println(a);
}
}
}运行结果
