corejava学习4(内部类)
1 Wrapper class
OverLoading 名相同，参数不同，返回类型不要求
1. //public void println(double d){}
//public void println(boolean b){}
public void println(Object o){}0.
2. int num=3;
double d=num;
Integer it=new Integer(3);
Double dd=it;
基本类型数据int可以向double自动扩展，但是包装类型之间
不能自动的相互转换
public class TestWrapper2{
public static void main(String[] args){
// int ------ Integer
int i1=3;
Integer it1=new Integer(i1);
Integer it2=Integer.valueOf(i1);
int i2=it1.intValue();
// Integer -------- String
Integer it3=new Integer(5);
String str1=it3.toString();
Integer it4=Integer.valueOf(str1);
Integer it5=Integer.getInteger(str1);
Integer it6=new Integer(str1);
// int ----------- String
String str2="1234";
int i4=Integer.parseInt(str2); //********
String str3=Integer.toString(i4);
String str4=i4+"";
}
}
Equals方法覆盖
public class TestToString {
public static void main(String[] args) {
String str1 = new String("abc");
//String str = "Hello";
String str2 = new String("abc");
System.out.println(str1 == str2);
System.out.println(str1.equals(str2));
//System.out.println(str1.toString());
//System.out.println(str1);
Student s1 = new Student("zhangsan" , 18);
Student s2 = new Student("zhangsan", 18);
System.out.println(s1 == s2);
System.out.println(s1.equals(s2));
//System.out.println(s.toString());
//System.out.println(s);
}
}
class Student{
String name;
int age;
public Student(String name,int age){
this.name = name;
this.age = age;
}
//设置toString方法覆盖，不然父类的方法的方法是打印地址。
public String toString() {
return "Name is " + name + " Age is " + age;
}
//设置equals方法的判断条件
public boolean equals(Object o) {
//标准的5步
if(o == null) return false;//1.是空就返回false
if(o == this) return true;//2.是自己就返回true
//if(!(o instanceof Student)) return false;//可以先这样写,标准写法是下面的
if(!(o.getClass() == this.getClass())) return false;//3.不是是同一种类就返回false
Student s = (Student)o;//4.强转
//判断名字和年龄都相等才相等
return (this.name.equals(s.name)) && (this.age == s.age);//5.根据具体数据判断
//return this.name.equals(s.name);//认为名字相等就相等//不是递归调用
//return this.age == s.age;//认为年龄相等就相等
/***************************************
*** Student s = (Student) o;
*** if(this.age == s.age) return true;
*** else return false;
***************************************/
}
}
--------------------------------------------------------------------------------------------------------
Private 方法，属性 本类
Default 方法，属性，类 在包
Protected 方法，属性 本包和子类
public 全部 到处可见
内部类：定义在其他代码块（类体或者方法体）里的类称为内部类。
编译后每一个内部类都会有自己的独立的字节码文件，文件名Outer$inner.java。
根据位置和修饰符的不同分为四种
1 member inner class 成员内部类
2 static inner class 静态内部类 （嵌套内部类）
类以内，方法之外，有静态修饰（static 可以 修辞内部类）
3 local inner class 局部内部类
方法里的类
4 annonymous inner class 匿名内部类
没有名字的类，只有这种没有构造方法。
Static inner class
1 定义的位置：类以内，方法之外，有静态修饰（static 可以 修辞内部类）
2 本身能定义的属性和功能：所有的属性和功能，包括静态和非静态
3 能直接访问什么：只能访问外部类的静态的功能和属性
4 怎么创建对象：outer.inner in=new outer.inner()
Member inner class 当作成员变量
1 定义的位置：类以内，方法之外
2 本身能定义的属性和功能：只能定义非静态的属性和方法
3 能直接访问什么：能访问外部类的所有的属性和功能
4 怎么创建对象：
Outer.Inner in1=new outer().new Inner()
Outer.Inner in2=outer.new Inner();
在Outer里提供一个getInner(),返回内部类的对象。
只要是类与接口就有字节码文件。
Local inner class 当作局部变量
1 定义的位置：方法之内，不能用public和static
2 本身能定义的属性和功能：只能定义非静态的属性和功能
3 能直接访问什么：能访问外部类的静态的功能和属性，以及方法的用final修饰的局部变量
4 怎么创建对象：相当于局部变量，只能在方法里创建对象。
Annonymous inner class
1、个特殊的局部内部类，没有名字，没有构造方法，可以实现一个接口或者继承一个类，生命周期里只能产生一个对象。
2、除了没有名字外，能定义的和能访问的都和普通的局部内部类一致。
3、当你试图创建接口或者抽象类对象的时候，用匿名内部类表示类本的｛｝紧跟在构造方法之后，调用匿名内部类的方法只能用写类时创建的那个对象。
public class T1{
public static void main(String[] args){
T1 t1=new T1();
/*int i=Integer.parseInt(args[0]);
Teacher t=t1.getTeacher(i);
t.teach(); */
t1..set(new Teacher(){
public void teach(){
System.out.println("CoreJava");
}
} , 3);
}
public void set(Teacher t,int num){
t.teach();
System.out.println(num);
}
public Teacher getTeacher(int num){
class George implements Teacher{
public void teach(){
System.out.println("EJB");
}
}
if(num==1) return new Teacher(){
public void teach(){
System.out.println("CoreJava");
}
};
else if(num==2) return new Teacher(){
public void teach(){
System.out.println("Web");
}
};
else return new Teacher(){
public void teach(){
System.out.println("EJB");
}
};
}
}
interface Teacher{
void teach();
}
class Outer{
public void get(){
Teacher t=new Teacher(){
public void teach(){ }
};
t.teach();
}
}
class A implements Teacher{
public void teach(){}
}
内部类也是类，也能继承和实现接口。
内部类的作用：
1. 不破坏访问权限的情况下，可以使用外部类的私有成员变量和方法。
2. 将接口公开，将实现类作成内部类隐藏起来，强制要求使用者使用接口，强制降低偶合度。
3. java通过接口和内部类两种机制来实现多继承。
关键字
Abstract do implements private throw boolean double import protected throws break else imstanceof public transient byte
Extends int return true case false interface short
Try catch final long static void char finally
Native super volatile class float new switch while
Continue for null synchronized default if package this goto const