javaSE总结（二）--java面向对象

一、类和对象

　　（1）类

【修饰符】 class 类名{
    //修饰符1：private public protected 三个最多出现其一
    //修饰符2：abstract final 两个最多出现其一
    //上面都可与static组合使用来修饰类
}

　　--每个单词首字母大写，其余字母小写
　　--最好不能是关键字，可以包含关键字

与类相关的构造器

【修饰符】 构造器名(形参列表)
{
    //修饰符：public private protected
    //构造器名：与类名相同
    //形参列表：和定义方法形参列表的格式相同
}

　　--构造器没有返回值

　　（2）对象

　　　　a) 创建对象

　　　　　　类名 对象名 = new 构造器名（）；

　　　　b) 对象调用　

　　　　　　对象调用类中的内容（没有被static修饰过）
　　　　　　　　1 调用方法： 对象名.方法名()； ==> per.say();
　　　　　　　　2 调用属性：对象名.属性名； 可赋值。例：per.name="测试";
　　　　　　　　3 this关键字：代表当前类的对象，this.方法名（）； this.属性名；

　　　　c) 对象的内存机制

person p=new  person(); 创建出对象后，会在分配内存存储这个对象，有两块内存。 一个是栈内存：存放p变量，p只是存放对象的变量名，它存储在堆内存中； 另一个是堆内存：存放实体对象，对象里的所有属性和方法都在栈内存中。 
栈内存中的变量会指向堆内存的对应的实体对象，p变量相当于一个引用。

　　（3）static静态　　　

　　　　1. static静态，可修饰方法、属性
　　　　2. 如果被static修饰的成员，那么此成员属于类的本身，使用该类作为主调；没有被static修饰过的，则属于该类的对象，通常使用对象调用（也可用类调用）。
　　　　3. 总结： 静态用类名调用
　　　　　　　　 非静态用对象调用（也可类名调用）

二、方法

 修饰关键字  [返回类型]  方法名称([参数类型  参数名称]){
       //方法内容
        [return 返回值]
}

注意：

　　-- 方法不能独立定义，方法只能在类中定义；方法不能独立执行，需要通过对象或类调用执行；同一个类中，不可出现两个以上相同的方法。
　　-- 方法重载：相同方法名，不同参数。

 

三、成员变量和局部变量

　　（1）成员变量

　　　　a) 实例变量：无static修饰

　　　　b) 类变量： 有static形式

　　（2）局部变量

　　　　a) 方法局部变量（在方法内定义）: 从定义该变量生效，到该方法结束是失效。

　　　　b) 代码块局部变量（在代码块内定义）: 从定义该变量时生效，到该代码块结束失效。

　　　　c) 形参（方法签名中定义的变量）: 在定义方法签名时，定义的变量，形参的作用域在整个方法内有效。

注意:
    局部变量与成员变量可以同名，局部变量覆盖成员变量的值。如果需要在这个方法里引用被覆盖的成员变量，则使用this(对于实例变量)或类名（对于类变量）作为调用者来限定访问成员变量。

四、面向对象的特征

　　（1）继承 extends

　　　　子类继承父类，子类便拥有父类的非私用方法和成员属性

　　　　a) 方法重写（override也称方法的覆盖）

方法重写遵循“两同两小一大”. 
   1 "两同": 方法名、形参列表相同
   2 "两小": 子类返回值类型要比父类的更小或相同；抛出的异常要比父类的异常类的范围要小。
   3 “一大”：子类方法的访问权限比父类方法的访问权限更大或相等。
注意：
      子类覆盖父类的方法后，子类对象无法访问父类中被子类覆盖的方法，可以调用子类中覆盖父类的方法。

　　　　b) super限定

super(); 调用父类构造器，只可在子类构造器中使用。
super.属性； 调用父类属性。
super.方法()；调用父类中的方法。

　　　　c) super注意

    1 在子类构造器中没有通过super（）调用父类构造器，系统默认隐式的调用父类无参构造器一次。
    2 子类构造器中只可调用一次父类构造器，普通方法可调用多次父类的属性或方法。

　　（2）封装

　　　　访问控制符
　　　　private(当前类访问权限) default（包访问权限） protected（子类访问权限） public（公共访问权限）

　　（3）多态

1.相同类型的变量，调用同一个方法时呈现出多种不同的行为特征，就是多态。
2.引用变量只能调用它编译时类型的方法，而不能调用它运行时类型的方法。
3.难以理解的话，这样记。father f=new son()； son子类的实例赋值给father父类的变量，f变量只能调用father父类中的内容

instanceof运算符：
    对象名 instanceof  类，判断前一个对象是否是后一个类（子类、实现类）的实例。若是返回true，否则返回false。

五、接口和抽象类

　　（1）接口

a 使用interface关键字修饰类，此类称为接口。
b 接口：1.所有的方法都是抽象方法（abstract可省略）。
         2.所用的成员变量都是静态常量（final 和 static可省略）。
c 接口可以继承接口，不可继承类，允许多继承。
一个类可以多实现多个接口。    

　　（2）抽象类

定义：抽象类和抽象方法必须使用abstract来修饰。有抽象方法的类一定是抽象类，抽象类可以没有抽象方法。
抽象类不能被实例化。
抽象类作为子类的模板，避免子类设计的随意性。

　　（3）接口和抽象类的异同

1.它们都不能被实例化，用于子类的继承和实现。
2.抽象类可以包含普通方法和抽象方法，普通成员变量和静态常量； 接口中只能定义抽象方法和静态常量。
3.接口没有构造器；抽象类有构造器，但不能实例化，用于子类调用 完成初始化操作。
4.接口中不能包含初始代码块；抽象类可以包含初始代码块。
5.一个类最多有一个直接父类，包括抽象类；但一个类可以实现多个接口。

 

六、包装类

　　描述：基本数据类型不具备“对象”的特性，没有成员变量、方法可以调用。包装类则存在对数据处理的方法，方便良好的对数据操作。通过自动装/拆箱，简化基本类型和包装类对象之间的转换。

　　类型：byte int short long character float double boolean string

　　包装类的相关方法：

　　　　（1）xxxvalue(): 将number对象转换为xxx数据类型的值并返回。小括号中无参数

bytevalue(); 以byte形式返回指定的数值。
doublevalue(); 以double形式返回指定的数值。
floatvalue(); 以float形式返回指定的数值。
intvalue(); 以int形式返回指定的数值。
longvalue(); 以long形式返回指定的数值。
shortvalue(); 以short形式返回指定的数值。
例： integer x=5; 
x.doublevalue(); //返回double原生数据类型

　　（2）compareto()：将number对象与参数比较。

integer x = 5;
int num=x.compareto(3);
如果指定的数与参数相等返回0。
如果指定的数小于参数返回 -1。
如果指定的数大于参数返回 1。

　　（3）equals()判断number对象是否与参数相等。
　　（4）valueof() 返回一个number对象指定的内置数据类型
　　（5）tostring()：以字符串形式返回值。

　　（6）parsexxx(): 将字符串解析为xxx类型。

parseint(): 将字符串解析为int类型。
parsefloat(): 将字符串解析为float类型。
parsedouble(): 将字符串解析为double类型。
parseshort(): 将字符串解析为short类型。
parselong(): 将字符串解析为long类型。

　　（7）random()：返回一个随机数0~1之间。

 

七、内部类

　　（1）定义：一个类在另一类的内部定义，这个在其他类内部的类被称为内部类（有的地方也叫嵌套类）。

　　（2）作用：

a 提供更好的封装，把内部类隐藏在外部类中，不允许同一个包中的其他类访问该类。
b 内部类可以直接访问外部类的私有属性 以及其他成员，内部类也可看做是内部类的其他成员。但外部类不能访问内部类中的实现细节（如内部类的成员变量）。
c 内部类可以比外部类多使用三个修饰符：private、protected、static-----外部类不可以使用。
d 非静态内部类不能拥有静态成员

　　（3）静态内部类/非静态内部类

　　　　a) 静态内部类

　　　　　　定义：使用static修饰的内部类，称静态内部类。 静态内部类属于外部类本身。

　　　　　　　　　静态内部类中可以包含静态成员，也可非静态成员。静态成员不能访问非静态成员。

　　　　　　  　　 接口中可以定义内部类，且内部类只能是静态内部类。

　　　　b) 非静态内部类

　　　　　　1 外部类不能直接访问内部类成员。在外部类中内部类外，通过创建内部类的实例，通过内部类实例访问内部类成员。（跟使用普通类的格式相同）

　　　　　　2  内部类可以直接使用外部类的成员。在内部类中，通过this、外部类类名.this作为限定区分。

　　　　　　　　a.this.成员名： 访问非静态内部类的实例变量，this.invarname
　　　　　　　　b.外部类名.this.成员名： 访问外部类的实例变量，outclass.this.outvarname

　　　　    注意：不允许在非静态内部类中定义静态成员

　　（4）使用内部类

　　　　a) 在外部使用内部类　

　　　　　　1 与平常使用普通类没有太大的区别，通过new调用内部类的构造器创建内部类的实例，用实例调用内部类中的成员。
　　　　　　2 不要在外部类的静态成员（包括静态方法和静态初始代码块）中使用非静态内部类，静态成员不能访问非静态成员。

　　　　b) 在外部类以外使用非静态内部类

1.private修饰的内部类，只能在外部类中使用。
2.省略访问控制符的内部类，只可被外部类处于同一包下的其他类使用。
3.protected修饰的内部类，只可被外部类处于同一包下的其他类和外部类的子类使用。
4.public修饰的内部类，任何地方都可以被使用。

使用非静态内部类的基本语法：
1. outerclass.innerclass  inner=new outerclass().new innerclass(); 创建了内部类的实例对象。
2. outerclass out=new outer();
    outerclass.innerclass in=out.new innerclass(); 同理也创建了内部类的实例对象。
3. 非静态内部类的构造器，必须使用外部类对象来调用。

当一个类继承了非静态内部类时，在子类构造器中会调用父类非静态内部类的构造器，需要将外部类的对象传递给子类构造器。因为非静态内部类的构造器必须通过外部类的实例对象调用。如下：
public class subclass extends out.in{
    public subclass(out out){
            //通过出入的out对象，调用in的构造器。
            out.super("hello");
}
}

　　　　c) 在外部类以外使用静态内部类

　　　　　　基本语法：
　　　　　　　　outerclass.innerclass in=new outerclass.innerclass();
　　　　　　　　因为静态内部类是外部类类相关的，因此在创建静态内部类对象时无法创建外部类的对象。

　　（5）局部内部类（方法内部类）　　　　

　　　　定义： 将一个类放入方法内中定义，则这个类成为局部内部类（方法内部类），局部内部类仅在该方法内有效。
　　　　　　1.方法外的任何地方 都不可调用局部内部类中的成员，只在方法内有效，
　　　　　　2.局部内部类不可以用static修饰。
　　　　　　3.如果需要用局部内部类定义变量、创建实例或派生子类，只能在局部内部类所处的方法内进行。

八、处理类成员和对象

 　　（1）处理对象

1 tostring(); 在打印对象的时，通过tostring() 方法，可以将对象的详细信息（"自我描述"）打印出来。不使用tostring ()方法，打印出的信息是对象的哈希值。
2 == 与equal 区别
    当判断的是基本数据类型，无区别。数值相等 即为相等
    当判断的是引用数据类型：==当数值和内存地址（同一对象）相等时，才为相等； equal 只数值相等，即为相等

　　（2）类成员

　　　　　成员变量，方法，构造器，初始代码块，内部类（包括接口，枚举）。=除构造器 都可用static修饰

　　　　　单例类： 一个类只可创建一个实例

　　（3）final 修饰符

a) final修饰的变量必须赋初始值
b) final修饰的变量，初始值存在之后，值定不可变。
    1 基本类型值不可变。
    2 引用类型，引用对象不可变，内存地址不可变，地址中的内容可以。如        
p.setname() 可改变对象中的内容。不可p=null; 这样内存中的地址就被消除，不可行。
    3 子类不可以重写父类中final修饰的方法
    4 final修饰的类为不可变类，不可被继承。