黑马程序员---java基础之day6-7

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

       面向对象：

              举例：

大象装进冰箱。

 

面向过程。

 

打开冰箱。

存储大象。

关上冰箱。

 

对于面向过程思想，强调的是过程(动作).

       用函数体现

C语言.

 

面向对象。

对于面向对象思想，强调的是对象(实体)。

冰箱打开。

冰箱存储。

冰箱关闭。

C++  Java  C#

特点：

1，面向对象就是一种常见的思想。符合人们的思考习惯。

2，面向对象的出现，将复杂的问题简单化。

3，面向对象的出现，让曾经在过程中的执行者，变成了对象中的指挥者。

 

 

 

 

 

 

              /*

用java语言对现实生活中的事物进行描述。

通过类的形式来体现的。

 

怎么描述呢？

对于事物描述通常只关注两方面。

一个是属性，一个是行为。

 

只要明确该事物的属性和行为并定义在类中即可。

 

对象：其实就是该类事物实实在在存在的个体。

 

类与对象之间的关系？

类：事物的描述。

对象：该类事物的实例。在java中通过new来创建的。

              一旦产生对象，该对象就拥有该类100%的描述

 

*/

 

 

/*

 

描述小汽车

 

分析：

1，属性。

       轮胎数。

       颜色。

2，行为。

       运行。

 

 

 

定义类其实就是在定义类中的成员。

成员：成员变量<-->属性，成员函数<-->行为。

 

 

成员变量和局部变量的区别：

 

1，

成员变量定义在类中，整个类中都可以访问。

局部变量定义在函数，语句，局部代码块中，只在所属的区域有效。

 

2，

成员变量存在于堆内存的对象中。

局部变量存在于栈内存的方法中。

 

3，

成员变量随着对象的创建而存在，随着对象的消失而消失。

局部变量随着所属区域的执行而存在，随着所属区域的结束而释放。

 

4，

成员变量都有默认初始化值。

局部变量没有默认初始化值。定义局部变量时要指定初始化值

 

 

 

*/

classCar

{

       intnum;

       Stringcolor;

      

       voidrun()

       {

              //int num = 10;

              System.out.println(num+"..."+color);

       }

 

}

class  CarDemo

{

       publicstatic void main(String[] args)

       {

              //在计算机中创建一个car的实例。通过new关键字。

//            Carc = new Car();// c就是一个类类型的引用变量，指向了该类的对象。

//            c.num= 4;

//            c.color= "red";

 

//            c.run();//要使用对象中的内容可以通过 对象.成员的形式来完成调用。

 

             

 

//            Carc1 = new Car();

//            c1.num= 4;

//            c1.color= "red";

 

//            Carc2 = new Car();

//            c2.num= 4;

//            c2.color= "red";

 

//            Carc1 = new Car();

//            Carc2 = new Car();

//            show(c1);

//            show(c2);

 

              /*

              匿名对象。没有名字的对象。

              newCar();//匿名对象。其实就是定义对象的简写格式。

              Carc = new Car();

              c.run();

 

              newCar().run();

      

 

              1，当对象对方法仅进行一次调用的时候，就可以简化成匿名对象。

             

              newCar().num = 5;

              newCar().color = "green";

              newCar().run();

 

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

 

              */

 

//            Carc1 = new Car();

//            show(c1);

              show(newCar());

       }

 

       //汽车改装厂。

       publicstatic void show(Car c)//类类型的变量一定指向对象。要不就是null。

       {

              c.num= 3;

              c.color= "black";

              System.out.println(c.num+"..."+c.color);

       }

}

 

              //基本数据类型参数传递

classDemo

{

       publicstatic void main(String[] args)

       {

 

              intx = 3;

              show(x);

              System.out.println("x="+x);

       }

       publicstatic void show(int x)

       {

              x= 4;

       }

}

 

//引用数据类型参数传递

classDemo

{

       intx = 3;

       publicstatic void main(String[] args)

       {

              Demod = new Demo();

              d.x= 9;

              show(d);

              System.out.println(d.x);

       }

       publicstatic void show(Demo d)

       {

              d.x= 4;

       }

}

 

 

 

       面向对象特点1：封装

              ·封装：是指隐藏对象的属性和细节，仅对外提供公共访问的方式。

              ·好处：

1，  将变化隔离。

2，  便于使用

3，  提高重用性

4，  提高安全性

·封装原则：

1，  将不需要对外提供的内容都隐藏起来。

2，  把属性都隐藏，提供公共方法对其访问

 

 

/*

人：

属性：

       年龄。

 

行为：

       说话。

 

*/

 

/*

private:私有，是一个权限修饰符。用于修饰成员。

              私有的内容只在本类中有效。

 

注意：私有仅仅是封装的一种体现而已。

 

 

*/

class Person

{

       private /*私有*/int age;

 

       public void setAge(inta)//setXxx getXxx

       {

              age = a;

       }

       public int getAge()

       {

              return age;

       }

       /*

       publicvoid haha(int a)

       {

              if(a>0&& a<130)

              {

                     age= a;

                     speak();

              }

              else

                     System.out.println("错误的数据");

       }

       */

       void speak()

       {

              System.out.println("age="+age);

       }

}

 

class  PersonDemo

{

       public static voidmain(String[] args)

       {

              Person p = newPerson();

//            p.age= -20;

              p.haha(-20);

//            p.speak();

       }

 

       public static voidselectSort(int[] arr){}

 

       private static voidswap(int[] arr,int a,int b){}

}

 

第7天：

              构造函数：

                     特点：

1，  函数名与类名相同

2，  不用定义返回值类型

3，  没有具体的返回值类型

作用：

       给对象进行初始化

注意：

1，  默认构造函数的特点

2，  多个构造函数是以重载形式存在的

 

 

class Person

{

       private String name;

       private int age;

 

       //定义一个Person类的构造函数。

       Person()//构造函数，而且是空参数的。

       {

             

              name ="baby";

              age = 1;

              System.out.println("personrun");

 

       }

      

      

       //如果有的孩子一出生就有名字。

       Person(String n)

       {

              name = n;

       }

 

 

       public voidsetName(String n)

       {

              name = n;      

       }

 

       Person(String n,int a)

       {

              name = n;

              age = a;         

       }

 

       public void speak()

       {

              System.out.println(name+":"+age);

       }

 

}

/*

//构造函数：构建创造对象时调用的函数。作用：可以给对象进行初始化。

创建对象都必须要通过构造函数初始化。

 

一个类中如果没有定义过构造函数，那么该类中会有一个默认的空参数构造函数。

如果在类中定义了指定的构造函数，那么类中的默认构造函数就没有了。

 

一般函数和构造函数什么区别呢？

 

构造函数：对象创建时，就会调用与之对应的构造函数，对对象进行初始化。

一般函数：对象创建后，需要函数功能时才调用。

 

构造函数：对象创建时，会调用只调用一次。

一般函数：对象创建后，可以被调用多次。

 

 

什么时候定义构造函数呢？

 

在描述事物时，该事物一存在就具备的一些内容，这些内容都定义在构造函数中。

 

构造函数可以有多个，用于对不同的对象进行针对性的初始化.

多个构造函数在类中是以重载的形式来体现的。

 

 

细节：

1，构造函数如果完成了set功能。set方法是否需要。

2，一般函数不能直接调用构造函数。

3，构造函数如果前面加了void就变成了一般函数。

4，构造函数中是有return语句的。

*/

class ConsDemo

{

       public static voidmain(String[] args)

       {

              Person p = newPerson();

//            p.speak();

              Person p1 = newPerson("旺财");

              p1.setName("旺旺");

 

              p1.speak();

 

              Person p2 = newPerson("小强",10);

              p2.speak();

       }

}

 

This:关键字

           /*

当成员变量和局部变量重名，可以用关键字this来区分。

 

this : 代表对象。代表哪个对象呢？当前对象。

          this就是所在函数所属对象的引用。

          简单说：哪个对象调用了this所在的函数，this就代表哪个对象。

 

this也可以用于在构造函数中调用其他构造函数。

注意：只能定义在构造函数的第一行。因为初始化动作要先执行。

*/

 

class Person

{

       private String name;

       private int age;      

       Person()

       {           

              name ="baby";

              age = 1;

              System.out.println("personrun");

       }    

       Person(String name)     

       {

              this();

              this.name = name;

       }

       Person(String name,intage)

       {

              this.name = name;

              this.age = age;       

       }

       public void speak()

       {

              System.out.println(this.name+":"+this.age);

       }

 

       /*

       判断是否是同龄人。

       */

       public booleancompare(Person p)

       {

              /*

              if(this.age==p.age)

                     returntrue;

              else

                     returnfalse;

              */

              returnthis.age==p.age;

       }

 

}

 

class ThisDemo

{

       public static voidmain(String[] args)

       {

 

              Person p1 = newPerson("aa",30);//

              Person p2 = newPerson("zz",12);

 

              p2.compare(p1);

//            newPerson();

//            Personp = new Person("旺财",30);

//            p.speak();

//            Personp1 = new Person("小强");

//            p1.speak();

       }

}

 

       对象被创建时便调用对应的构造函数进行初始化

对象调用函数时（调用构造函数也一样），都持有该对象的this引用，this表示该对象

 

 

 

 

 

 

 

 

 

静态内存图详解：

classPerson

{

       Stringname;//成员变量，实例变量

       staticString country = "CN";//静态变量。类变量

       public  void show()

       {

              System.out.println(Person.country+":"+this.name);

       }

}

 

 

/*

static的特点：

1，static是一个修饰符，用于修饰成员。

2，static修饰的成员被所有的对象所共享。

3，static优先于对象存在，因为static的成员随着类的加载就已经存在了。

4，static修饰的成员多了一种调用方式，就可以直接被类名所调用。类名.静态成员。

5，static修饰的数据是共享数据，对象中的存储的是特有数据。

 

成员变量和静态变量的区别？

1，两个变量的生命周期不同。

       成员变量随着对象的创建而存在，随着对象的被回收而释放。

       静态变量随着类的加载而存在，随着类的消失而消失。

 

2，调用方式不同。

       成员变量只能被对象调用。

       静态变量可以被对象调用，还可以被类名调用。

 

3，别名不同。

       成员变量也称为实例变量。

       静态变量称为类变量。

 

4，数据存储位置不同。

       成员变量数据存储在堆内存的对象中，所以也叫对象的特有数据.

       静态变量数据存储在方法区(共享数据区)的静态区，所以也叫对象的共享数据.

 

 

 

静态使用的注意事项：

1，静态方法只能访问静态成员。(非静态既可以访问静态，又可以访问非静态。静态先于对象而存在)

2，静态方法中不可以使用this或者super关键字。

3，主函数是静态的。

 

 

 

 

 

*/

 

class StaticDemo

{

       intnum = 4;

       publicstatic void main(String[] args)

       {

//            Person  p = new Person();

//            p.name = "小强";

//            p.show();

//            System.out.println(p.country);

//            System.out.println(Person.country);

//            Person.show();

              newStaticDemo().show();

       }

 

       publicvoid show()

       {

              System.out.println(num);

       }

}

 

/*

public static voidmain(String[] args)

 

主函数特殊之处：

1，格式是固定的。

2，被jvm所识别和调用。

 

public:因为权限必须是最大的。

static:不需要对象的,直接用主函数所属类名调用即可。

void：主函数没有具体的返回值。

main:函数名，不是关键字，只是一个jvm识别的固定的名字。

String[] args:这是主函数的参数列表，是一个数组类型的参数，而且元素都是字符串类型。

 

*/

 

class MainDemo

{

       publicstatic void main(String[] args) //new String[0]

       {

              /**/

//            System.out.println(args);//[Ljava.lang.String;@c17164

              System.out.println(args.length);

              for(intx=0; x<args.length; x++)

                     System.out.println(args[x]);

             

       }

}

 

/*

静态什么时候用？·

1，静态变量。

       当分析对象中所具备的成员变量的值都是相同的。

       这时这个成员就可以被静态修饰。

       只要数据在对象中都是不同的，就是对象的特有数据，必须存储在对象中，是非静态的。

       如果是相同的数据，对象不需要做修改，只需要使用即可，不需要存储在对象中，定义成静态的。

 

2，静态函数。

       函数是否用静态修饰，就参考一点，就是该函数功能是否有访问到对象中的特有数据。

       简单点说，从源代码看，该功能是否需要访问非静态的成员变量，如果需要，该功能就是非静态的。

       如果不需要，就可以将该功能定义成静态的。当然，也可以定义成非静态，

       但是非静态需要被对象调用，而仅创建对象调用非静态的

       没有访问特有数据的方法，该对象的创建是没有意义。

 

*/

 

class Demo

{

       intage ;

       staticint num = 9;

       Demo(intage)

       {

              this.age= age;

       }

 

       publicstatic  void speak()

       {

              System.out.println(num);

       }

       publicvoid show()

       {

              System.out.println(age);

       }

 

}

 

class StaticDemo3

{

       publicstatic void main(String[] args)

       {

//            Demo d = new Demo(30);

//            d.speak();

              Demo.speak();//对像是访问特有数据的，没访问特有数据对象的创建是没有意义的

 

//            System.out.println("HelloWorld!");

       }

}

 

静态代码快：

 

/*

 

静态代码块。

随着类的加载而执行。而且只执行一次。

 

作用：

       用于给类进行初始化。

*/

class StaticCode

{

       staticint num ;

       static

       {

              num= 10;

//            num *=3;

              System.out.println("hahahah");

       }

       StaticCode(){}

 

       staticvoid show()

       {

              System.out.println(num);

       }

}

 

class Person

{

       privateString name;

      

      

 

       {//构造代码块。创建一次对象调用一次，可以给所有对象进行初始化的。

 

              System.out.println("constructorcode ");

//            cry();

       }

      

       static

       {

              System.out.println("staticcode");

       }

      

       Person()//是给对应的对象进行针对性的初始化。

       {

              name= "baby";

//            cry();

       }

       Person(Stringname)

       {

              this.name  = name;

//            cry();

       }

       publicvoid cry()

       {

              System.out.println("哇哇");

             

       }

 

       publicvoid speak()

       {

              System.out.println("name:"+name);

       }

 

       staticvoid show()

       {

              System.out.println("showrun");

       }

}

 

 

class StaticCodeDemo

{

       static

       {

//            System.out.println("a");

       }

       publicstatic void main(String[] args)

       {

 

//            Person p = null;

//            p.speak();

 

//            Person.show();

//            Person p1 = new Person();

//            p1.speak();

//            Person p2 = new Person("旺财");

//            p2.speak();

//            new Person();

             

 

//            new StaticCode().show();

//            new StaticCode().show();

//            StaticCode.show();

//            System.out.println("b");

       }

}