黑马程序员——对象

 

　　------- android培训、java培训、期待与您交流！ ---------- 

 

对象：

对象：EVERYTHING IS OBJECT（万物皆对象）

 

每个对象都有两个方面：

属性：用来描述对象的状态特征（颜色，长短，深浅等表达对象有什么。）

方法：用来告诉外界的对象有哪些功能，此对象能做什么（手可以开门，门可以旋转）

 

拓展：一个大的对象的属性也可以是一个对象。

 

因为面向对象符合人类看待事物的一般规律。

 

对象的方法的实现细节是屏蔽的，只有对象方法的实现者了解细节。所以外部调用对象的方法时不需要关系方法是如何实现的。也因此对于程序员，方法的定义就非常重要了。

 

面向对象：

 

面向对象：将功能封装进对象，强调的是具备了功能的对象，二不是具备的功能（并不是说不重要）。站在对象的角度考虑问题的一种思想。

 

比较面向对象与面向过程：

面向过程注重的是过程， 强调的是功能行为。

面向对象注重的是对象，强调的是具备了功能的对象。

 

类（class）：

类（class）：类是对象的总称，比如车是某个类，而我买的小轿车是类的对象。类比喻为工厂。

类描述的是事物，而对象是类事物的实例，在程序中通过new 来创建。对象比喻为工厂生产出来的车。

 

例子：车

类在程序中的定义：

车

{

属性：轮胎数目，车颜色等； 其中属性就是成员变量。

 

方法：运行，刹车等 其中方法就是成员函数。

}

 

因为工厂里面将要生产的车的属性是可以变化的，所以是在车这个类里面的成员的变量；函数就是数学里面方法的表达方式，例子如下：

                  class Car

                              {

                                       Stringcolor = "green";//成员变量

                                       int num;//成员变量

 

                                       voidshow() //成员函数

                                       {

                                             System.out.println("color="+color+"..num="+num);//函数体

 

                                       }

                              }

 

                             class CarDemo  //这里起到测试的作用

                             {

                                      publicstatic void main(String[] args)

                                      {

                                             Car c= new Car();//新创建一个汽车实体

                                            c.color = "red";//对汽车的属性（成员变量）进行修改

                                            c.show();//使用对象的功能（成员函数）。

                                      }

                              }

 

对象在程序中的实现方法：

 

车  我的车；  即我的车是车这个类中的一个实例。

我的车 = new 车；  即我的车是在车这个类中新创建的。

 

特殊的对象----匿名对象

 匿名对象是对象的简化形式

例如:Car c = new Car();

c.show();        等价于         new Car().show;   //匿名对象直接调用show方法。

 

 什么情况下使用匿名对象？

1.当对对象的方法只调用一次时(调用变量没意义)，可以用匿名对象来完成。

          所以如果对一个对象进行多次调用，必须给这个对象起个名字。

2.可以将匿名对象作为实际参数进行传递。

所以假如：

Car c1 = new Car();

c1.show(); 

c1.run();  //多次调用时不应该使用匿名对象。

 

基本数据类型

在数据类型中，最基础的数据类型被称作基本数据类型。

有8 种，按照用途可以分出4 类：

 

定点类型int：代表整数值的类型。

 

浮点类型double和float：根据精度和存储区间的不同，设计了两种小数类型。

 

字符型char：代表特定的某个字符。计算机中Unicode 字符集作为默认的字符集，该字符集包含各种语言中常见的字符。在程序代码中，字符使用一对单引号加上需要表达的字符来标识，例如’A’、’b’等。

 

布尔型bealoon：代表逻辑中的成立true和不成立false。

 

基本数据类型转换可以相互转换：

向上转换（隐式类型转换）：

byte,short,char → int → long → float → double

byte，short，char之间不会相互转换，他们在计算时会首先转换为int类型。

boolean 类型是不可以转换为其他基本数据类型。

 

向下转换（显式类型转换）：

byte,short,char → int → long → float → double

byte，short，char之间不会相互转换，他们在计算时首先会转换为int类型。

boolean 类型是不可以转换为其他基本数据类型。

 

基本数据类型的包装类

竟然万物皆对象，所以把把基本数据类型包装起来就是他们的包装类。通过把他们变成类可以像处理类一样操作他们。

 

int的包装类为：Integer

char的包装类为：Character

其余的数据类型就是他们的字母，其中只需要首字母大写就可以。

 

特点：

Integer,Byte,Float,Double,Short,Long都是Number类的子类。

Character和Boolean都是Object直接子类；

这8个类都是final修饰的不可被继承的类。

 

装箱：把基本数据类型变为包装类（在Java5后已经是自动的过程）。

拆箱：把包装类变为基本数据类型（在Java5后已经是自动的过程）。

注意：
除了Character外，其他包装类都可以传入一个字符串参数构建包装类对象。

 

Eg：

Integer i = 3;装箱

int j = i;拆箱

Booleana = (Boolean)true;装箱

booleanb = a;拆箱

 

字符串String

由“ ”包含起来的一串字符。比如“我在学java！”

格式：

String s = “学Java，上黑马！”；

String a = new String（）；//初始化一个新的 String 对象。

 

对应的方法：

获取：

char charAt(int index):取字符串中指定位置的字符，index从0开始计算。

String concat(String str):连接字符串，等同于 “+”；

判断：

boolean contentEquals(StringBuffer buffer):若二者包含的字符序列相同时就返回true;

boolean equals(Object obj):将该字符串与指定对象比较，若二者包含的字符序列相等返回true；

boolean startsWith(String prefix) 测试此字符串是否以指定的前缀开始.

boolean equalsIgnoreCase(StringanotherString) 将此 String 与另一个String 比较，不考虑大小写;

修改：

byte[] getBytes():将该字符串转换成byte数组；

String replace(char oldChar, char newChar) :返回一个新的字符串，通过用 newChar 替换所有 oldChar

String replaceAll(String regex, Stringreplacement) 使用给定的字符串replacement 替换此字符串所有的regex字符串; 

String[] split(String regex)： 把字符串按指定的字符串分隔开。

String toLowerCase() 将此 String 中的所有字符都转换为小写;

String toUpperCase()转成大写;

static String valueOf(基本类型 obj):把基本类型值转成字符串;

String substring(int beginIndex) 返回一个新的字符串，从beginIndex开始截取，它是此字符串的一个子字符串;

String substring(int beginIndex, intendIndex) 返回一个新字符串，它是此字符串的一个子字符串;[begin,end)

char[] toCharArray() 将此字符串转换为一个新的字符数组。

String trim() ：忽略字符串前导空白和尾部空白。

  查找：

int indexOf(String str):找出str字符串在该字符串中第一次出现的位置；

int indexOf(String str, int fromIndex) 返回str在此字符串中第一次出现处的索引，从fromIndex开始;

int lastIndexOf(String str) 返回指定子字符串在此字符串中最后一次出现处的索引;

int length():返回当前字符串长度

基本类型和String之间的转换：

String → 基本类型： int i = Integer.parseInt(str);

基本类型 → String：Strings1 = String.valueOf(i)

 

有数据就会有运算：

运算符

运算符：一种特殊符号，用来表示数据的运算、赋值和比较等。

 

算术运算符（+ 、— 、* 、/ 、%）   1+1   2*2=4    %百分比取余数：3%2=1

赋值运算符（= 、+=、-=、*=、/=,、%=） 

关系运算符（>、>=、<、<=、!=）  ！= 不等于

条件运算符（&&、||、！&、|、^）

位运算符（&、|、^、~、>>、<<、<<<、>>>）

 

“&”和“&&”的区别：

单&时，左边无论真假，右边都进行运算；双与&&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。

“|”和“||”的区别：

双或时，左边为真，右边不参与运算。

“ ^”与“|”的区别：

当左右都为true时，"^"结果为false。

有了运算就有表达式：

表达式

数字、运算符、数字分组符号(括号)等有意义的排列的序列。

a + b    

3.14 + a

(x + y) + z *w

表达式的类型和值：

       对表达式中操作数进行运算得到的结果是表达式的值。

       表达式值的数据类型即为表达式的类型。

运算顺序：

按照运算符的优先级;优先级相同的运算符按从左到右运行;

 

Java中特殊的：三目运算符

             x ? y :z;

得出结果是真假，先计算x的值，如果为真，那么三目运算符的结果是y的值，否则就是z的值。

变量与作用域：

变量：在内存中的某一个有自己的名称（变量名）和类型（数据类型）的存储区域存储着的的数据可以在同一类型范围内不断变化（重复使用，有范围和初始化值）。

 

作用范围：定义开始到定义它的代码块结束;

同一范围内，不允许多个个局部变量命名冲突

 

定义变量的格式：数据类型    变量名  =  初始化值；

 

作用域：既一个变量有效的范围。

成员变量：定义在方法体外类内部的变量，一般作为类的属性。 如上面的color和num。

局部变量：定义在方法之中的变量。如上，假如成员方法内部有按照color定义变量，即为局部变量。局部变量调用前要初始化，否则编译的时候会报错！

 

比较局部变量与成员变量：

l 成员变量有默认初始化的值；局部变量没有，所以最好在定义时候就赋值。

l 局部变量不允许在范围内定义两个同名变量。

l 成员变量的作用域在本类中完全有效，当被其他的类调用的时候也可能有效。

l 成员变量和局部变量允许命名冲突（最好不要）。

l 成员变量存在堆内存的变量中；局部变量存在于栈内存的方法中。

l 成员变量随对象创建创建，消失而消失；局部变量在局部区域被对象调用时出现，调用结束时释放。

 

构造方法：

构造方法：方法中的一类特殊方法。当用类生成对象时，系统在生成对象的过程中利用的方法。

 

构造函数的特点

1.函数名与类名相同   

 2.不用定义返回值类型（void也是一种返回值类型），构造方法没有返回值。格式为：public 方法名。

3.不可以写return语句，因为没有返回值类型。

 

注意：

l 构造方法在生成对象的时候会被调用，但并不是构造方法生成了对象。他只是帮助初始化了对象。

l 可以构造多个构造方法，但多个构造方法的参数表一定不同。

l 如果我们未给系统提供一个构造方法，那么系统会自动提供一个为空的构造方法。

 

 

比如：对于student这个类可以定义下面两个构造方法，但是因为他们参数表顺序不同（任何不同都可以），所以是不同的构造方法。

public student(string name,int a){

}

public student(int a,string name){

}

 

 

应用：

用类来生成对象的语句：

Student  a=new Student()。

 

解释：第一个Student表示这是用Student类进行定义的。

而“Student()”表示调用一个无参数的构造方法。

如果()中有参数，则系统构造对象的过程中调用对应的方法。

此时a称为一个对象变量。a的存储区域存放的是地址：一个对象在内存上占有一个连续地址，首地址赋予a的空间。a称为对象Student的引用。

 

注意：

l 在对象变量中存放的一定是引用（地址）；在成员变量中存放的是数值等。

重载（overloading）和覆盖（overriding）：

构造方法可以实现overloading。

例：

public  void  teach(){};

public  void  teach(int a){};

public  void  teach(String a){}是三种不同的方法。

 

this（关键字）：

 this语句 :用于构造函数之间进行互相调用。

 this语句只能定义在构造函数的第一行。因为初始化要先执行。

 this代表它所在函数所属对象的引用。即：哪个对象在调用this所在的函数，this就代表哪个对象。

类中成员之间的互相调用的时候其实都是对象完成的，只不过是省略了this。

 

this在代码中的应用：

当定义类中的功能时，如果函数内部要用到调用该函数的对象就this来表示这个对象。

 

                          class Car

                          {

                                    private String color;

                                    private int num;

                                    Car(String color)

                                    {

                                            this.color =color;

                                    }

                                    Car(String color,int num)

                                    {

                                            this(color);//调用上一面的对应的构造函数

                                            this. num = num;

                                    }

                          }

覆盖的概念存在于继承体系：

如同儿女继承父亲的特征与能力，但是儿女的能力和父亲有不同，那么儿女的能力就是覆盖了父亲的能力（）父亲的能力可以继续在父亲这个类的实例中调用。

 

代码块

指的是使用"{}"括起来的一段代码，有4种:

代码块里变量的作用域：

只在自己所在区域(前后的{})内有效；

 

普通代码块：

即直接定义在方法或语句中的代码块：

publicvoid run()

{

普通代码块

}

 

构造代码块：

直接写在类中的代码块，其优先于构造方法执行，每次实例化对象之前都会执行构造代码块。

作用：给对象进行初始化，对象一创建就运行，并且优先于构造函数。

 

和构造函数的区别：              

构造代码块给所有类的对象都进行初始化。如所有车已经造出来就有4个人轮胎 。

构造函数给类的特定对象进行初始化。       如有些车造好了就有了名字，有些就没有。         

Eg：

public class Demo 

{

    {

            System.out.println("构造代码块");

    }

   public Demo(){

             System.out.println("构造方法");

    }

   public static voidmain(String[] args) {

            Demod1  = new Demo();        //构造代码块

                                                 //构造方法

           Demod2 = new Demo();      //构造代码块

                                                 //构造方法

 }}

静态代码块

使用static 修饰的构造代码块:

优先于主方法执行，优先于构造代码块执行，不管有创建多少对象，静态代码块只执行一次，可用于给静态变量赋值；

 

Eg：

public class Demo {

  Demo(){

     System.out.println("构造方法！");//创建对象时候使用！

   }

   {

     System.out.println("构造代码块！");//实例化对象的时候才会去调用！

   }

  static{

      System.out.println("静态代码块！");//第一次加载类的时候才会去调用，且只调用一次！

   }

 

  public static void main(String[] args) {

     new Demo();

     new Demo();//再次创建对象，证明无论创建几次对象，静态代码块都只执行一次

     System.out.println("普通代码块！");

   }

}

 

输出：

静态代码块！

构造代码块！

构造方法！

构造代码块！

构造方法！

普通代码块！            

                          

所以有优先级：静态代码块 　＞　构造代码块　＞　普通代码块

 

单例模式：饿汉式和懒汉式

模式：前人归纳总结的在满足使用条件下应该利用的实现思想与编码形式。能有效提高代码的质量与编码速度。

单例模式：整个应用中有且只有一个实例，所有指向该类型实例的引用都指向这个单独的实例。

饿汉式单例：直接将对象定义出来（很饿了，一开始就吃）。饿汉式，方法相对简单，由static修饰。

class SingleDemo{

  private static SingleDemo s = newSingleDemo();

  private SingleDemo(){}//私有化的构造方法使外界不能构造对象。

  public static SingleDemogetS1() {

     return s;

   }

}

 

 懒汉式单例：只给出变量，并不将其初始化（因为懒，所以不得已的时候才定义）。懒汉式 ，第一次因为需要加载，涉及不安全线程所以用的时候相对较慢。

class SingleDemo{

  private static SingleDemo s ; 

  private SingleDemo(){ }

  public static SingleDemo2getS3()

{

     if(s3 == null){

       s3 = new SingleDemo2();

     }//这个时候才创建对象。

     return s3;

   }

}