java笔记第十章之Object和内部类

第十章 object类和内部类

@ Object类

  java.lang.Object 是java中所有类的直接父类或者间接父类；所有类的对象都可以声明称Object引用

  Object o1=new MyClass() ; 这里用到多态

#Object的子类继承了Object的方法（常用的有 getClass(),equals(),toString()）所有子类都可以对这几个方法进行覆盖

 父类也叫超类

#。getClass() 方法：返回一个对象的实际类型

  变量有两个类型，声明时有个类型，运行时又有一个类型，多态就是靠这样

  Class A{}

  Class B extends A{}

  pulbic class c{

public static void main(String args[]){

Object object=new A();  //这里就是object是个引用，这时是声明他的类型是Object类

object.getClass();//这里Object到了运行时，他变成了另外一个类型A类型，这就是多态

        Object object1=new B();

}

}

小程序理解getClass(); instanceOf和getclass的区别  instanceof是判断一个对象是否属于莫个类或莫个父类   而 getClass是当前类

pulic class c{

public static void main(String args[]){

Object o1=new A();

}

}

#,equals:比较两个对象的内容是否相等，

(1)Student s1=new Student("sun",30);

Student s2=new Student("sun",30);

system.out.println(s1.equals(s2))//false ，因为现在使用的equals是父类Object中默认实现的方法，在Object中equals比较的是对象引用的地址，所以这里肯定为false

(2)String s1=new String("name");

String s2=new String("name");

system.out.println(s1.equals(s2))//true  这里因为String类中已经覆盖了equals方法，而Student类中没有覆盖

Student类可以这样覆盖：

Boolean equals(Object o){

Student s=(Student)o;

if(this.name.equals(s.name)&&this.age==s.age){

return true;

}else{

return false;

}

}//挡在eclipse中操作时可以这样 单击右键，找到source，再点hashcode() and equals()这个选项

#，ToString()方法：返回一个对象的字符串表现形式

class Student{

 String name;

 int age;

}

 main{

Student s=new Student();

system.out.println(s.toString)//打印出Student@128fee

system.out.println(s)//student@128fee  对象名后可省略toString 打印出内存地址，但这些对我们没什么意义，所以我们可以去重写它，来展示对象中的内容

}

@，包装类的概念（8种基本类型数据转化成对象）

基本类型 byte short int long float char

包装类  Byte  Short Integer Long Float Charactor

int 转Integer（装箱）  int i=10；Integer I=new Integer（i）；

Integer转int（拆箱）  Integer I=new Integer(10),int i=I.intValue();

Integer中有很多方法可以用，这就是转换对象的好处

String转int

String s=“20”；//必须是整的格式

int i=Integer.paseInt(s);

int转String

int i=20；

String s1=String.valueOf（i）;或String s2=“”+i；//两种方式。第二种更简单

@内部类

#内部类概念：定义在类中的类

1，成员内部类 2，静态内部类 3，局部内部类 4，匿名内部类

#成员内部类：

Class MyOuterClass{

String outValue;

Class MyInnerClass{

String inner value;

public void test1(){};

}

获得内部类的方法：1，在外部类中定义方法直接把内部类New出来 2，在其他类中创建内部类，先创建外部类

public static void main(string args[]){

OutClass outerClass=new OuterClass();//第二种方法MyOutClass out=new MyOutClass();

InnerClass innerClass=outerClass.m();             MyOutClass.MyInnerClass in=out.new MyInnerClass();

}

}

#成员内部类的特点：1，可以获得外部类的私有属性 2，可以为成员内部类家private进行封装

 当内部类中访问外部类中的变量（内部类和外部类有相同的变量名时） 这时用OuterClass.this.name

@，静态内部类：（和上个类一样，不过在class前加个static）

  创建内部类对象：MyOutClass.MyStaticInner in=new MyOutClass.MyStaticInner();//不用先创建外部类

区别：

1，在其他类中创建内部类对象时，创建语法不同

2，在静态内部类中只能访问外部类中的静态成岩，可以定义静态方法

3，在成员内部类中能访问外部类中所有静态成员，非静态成员，但不能定义静态方法

@局部内部类：

1，必须定义在方法内，在方法内才有效

2，只有方法内才能创建对象，局部内部类可以访问外部类变量

3，局部内部类在访问局部变量时，局部变量必须声明成final

@匿名内部类：是特殊的局部内部类

当满足如下2个条件时可以选择应用匿名内部类；

1，局部内部类可能就需要创建一个对象

2，局部内部类需要实现外部接口或者继承莫些父类

interface MyInterface{

  void m();

}

new MyInterface(){

void m(){

sysout("hh")

}

};

//匿名内部类的好处（实现了接口，以前用类实现，对象只能使用一次，没有名字，其他的类想调用它也调用不成，要是用类的话，其他的类可以调用）