黑马程序员_java学习日记02

 

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

 

      环境变量path和classpath的作用是什么？

             path：

             作用是指定命令搜索路径，在命令行下面执行命令如javac编译java程序时，它会道path变量所指定的路径中查找看是否能找到相应的命令程序。我们需要把jdk安装目录下的bin目录增加到现有的path变量中，bin目录包含经常要用到的可执行文件如javac/javadoc等，设置好path变量后，就可以在任何目录下执行javac/java等工具了。

             classpath

             作用是指定类搜索路径，要使用已经编写好的类，前提当然是能够找到他们。Jvm就是通过classpath来寻找类的。

             语句嵌套形式，其实就是语句中还有语句。

             嵌套循环：例如：

      classForForDemo

             {

      publicstatic void main(String[] args)

      {

             for(intx = 0;x<3;x++)

             {

                    For(inty = 0;y<x;y++)

                    {

                           System.out.println(“ok”);

}

}

}

}

      class FFTest

{

      public staticvoid main(String[] args)

      {

             for(intx=0;x<5;x++)

 

             {

                    for(inty=x;y<5;y++)

 

                    {

                           System.out.print("");

                    }

                           for(intz=0;z<=x;z++)

                           {

                                  System.out.print("*");

                           }

                           System.out.println("");

             }

      }

      打印结果：

     *

    *  *

   *  *  *

  *  *  *  *

 *  *  *  *  *

不是规律的规律，尖朝上，可以改变条件，让条件随着外循环变化。尖朝下，可以初始化值，让初始化随着外循环变化。发现图形有很多行，每一行有很多列。要使用嵌套循环，原理：形象说法：大圈套小圈。

打印九九乘法表：

1*1=1

1*2=2 2*2=4

1*3=3 2*3=6 3*3=9

代码如下：

class ForForDemo

{

      public staticvoid main(String[] args)

      {

             for(intx=1;x<=9;x++)

                    {

                           for(inty=1;y<=x;y++)

                           {     

                           System.out.println(y+”*”+x+”=”+x*y+”\t”);

}

      System.out.println();

}

}

}

循环注意：一定要明确哪些语句需要参与循环，哪些不需要。

      Break(跳出)：应用范围，选择结构和循环结构。在一系列嵌套循环中使用break语句时，它将仅仅终止最里面循环。Continue：只能作用于循环结构。继续循环。特点：接受本次循环，继续下一次循环。continue停止执行当前的反复，然后退回循环起始，开始新的反复。continue用于跳过循环体中的一部分语句，也就是不执行这部分语句。

      注意:     1、Break和continue语句的的作用范围。使用break退出循环可以使用break语句直接强行退出循环，忽略循环体中任何其他语句和循环条件测试。

                    2、break和continue单独存在时，下面可以有任何语句。因为执行不到。

      

 

例子：

class Test{

    public staticvoid main(String[] args)

    {

       for(inti=1;i<=100;i++)

       {

           if(i==99)

           break;        //返回              

           System.out.print(i+",");

 

           if(i%10==0)  

           {  

             System.out.println();  //遇到10的倍数换行

           }

       }

    }

}

 

Continue用法示例：

class FFTest

{

       public static voidmain(String[]args)

       {

           String s="";

      

              for(int i =1;i<=5;i++)

              {

                     if(i==3||i==4)

                     continue;

                     s+=i;

             

                     System.out.println(s);

              }

       }

}

 

输出结果：

1

12

125

可以看出没有输出3、4。它的作用就是在循环中继续循环，而不执行本次循环后的语句。

获取最大值的问题,如何从一个数字组中获取最大值?

先看一个小例子：

获取最大值得步骤：

1.    定义变量，初始化为数组中任意一个元素即可。

2.    通过循环语句对数组进行遍历。

3.    在变量过程中定义判断条件，如果遍历到的元素比变量中的元素大，就赋值给该变量。

需要定义一个功能来完成，以便提高复用性。

1.    明确结果，数组中的最大元素 int。

2.    未知内容：一个数组，int[];

class getMax

{

       public static voidmain(String[] args)

       {

              int[]arr={98,45,78,23,78,90,67,43,23,546,45}; // 定义数组

              int max = getMax(arr);                                    //定义获取最大函数

              System.out.println(“数组的最大值为：”+max);

}

public static int getMax(int[] arr)

{

       int temp = 0;

       for(intn:arr)

       {

              temp =(n>temp)?n:temp;

}

 

       return  temp;

}

}

获取最值的思路：

1.    获取最值需要进行比较，每一次比较都会有一个较大的值，因为该值不确定。此时需要通过一个变量进行临储。

2.    让数组中的每一个元素都和这个变量中的值进行比较。如果大于了变量中的值，就用该变量记录较大值。

3.    当所有的元素都比较完成，那么该变量中存储的就是数组中的最大值了。

 

/*

对1-100之间7的倍数的个数进行打印。

思路：

1.    先对1-100进行循环（即遍历），通过循环的形式。

2.    在遍历的过程中，定义条件，只对7的倍数进行操作。

3.    因为7的倍数不确定，只要符合条件就通过一个变量来记录住这个变化的次数。

步骤：

1.    定义循环语句，用for循环。

2.    在循环中定义判断，只要是7的倍数即可，使用if语句，条件：7的倍数，即 x%7==0.

3.    定义变量，该变量随着7的倍数的出现而自增。

*/

class  ForTestA

{

       public static voidmain(String[] args)

       {

              int count = 0;

              if(x%7==0)

              {

                            count++;

}

System.out.println(“数目为：”+count);

}

}

这个过程其实就是累加思想。（即计数器思想）

原理：通过一个变量记录住数据的状态变化。也可通过循环完成。

函数定义：就是在类中的具有特定功能的一段独立小程序。也成为方法。

函数的格式：

             修饰符返回值类型 函数名（参数类型 形式参数1，参数类型 形式参数2，……）

{

                                          执行语句；

                                          return返回值；

              }

//发现以上的运算，因为获取不同数据的运算结果，代码出现了重复。为了提高代码的复用性，对代码进行抽取。将这个部分定义成一个独立功能，方便与日后使用。java中对功能的定义是通过函数的形式来体现的。

返回值类型：函数运行后的结果的数据类型。

参数类型：是形式参数的数据类型。

形式参数：是一个变量，用于存储调用函数是传递给函数的实际参数。

实际参数：传递给形式参数的具体数值。

return :用于结束函数。

返回值：该值会返回给调用者。

 

重载

99乘法表

class FunctionTest

{

       publicstatic void main(String[] args)

       {

              for(int  x=1;x<=9;x++)

                     {

                            for(inty=1;y<=x;y++)

                            {

                                   System.out.println(y+”*”+x+”=”+y*x+”\t”);

}

System.out.println();

}

}

}

什么时候用重载（voerload）？

当定义的功能相同，但参与运算的未知内容不同。那么，这时就定义一个函数名称以表示其功能，方便阅读，而通过参数列表的不同来区别多个同名函数。

概念，在同一个类中，允许存在一个以上的同名函数，只有他们的参数胡总参数类型不同即可。

 

重载的特点：与返回值类型无关，只看参数列表。

重载的好处：方便于阅读，优化了程序设计。

重要示例：

//返回两个整数的和。

int add(int x;int y){return x+y};

//返回两个整数的和。

int add(int x;int y;int z){return x+y+z};

//返回两个小数的和。

double add(double x;double y){return x+y};

//重载只和函数类型有关系。

class FunctionOverload

{

       public static voidmain(String[] args)

       {

              System.out.println(“你好，java！”);

}

//定义一个加法运算，获取两个整数的和。

public static int add(int x;int y)

       {

              returnx+y;

}

//定义一个加法，获取三个整数的和。

public static int add(int x;int y; int z)

{

       return x+y+z；

}

public static void print99(int num)
{

for(int x=1;x<=num;x++)

       {

              for(inty=1;y<=x;y++)

              {

                     System.out.println(y+”*”+x+”=”+y*x+”\t”);

}

System.out.println();

}

}

}

判断下列各选项是否重载？

void show(int a;chr b;double c){}

a.

void show(int x;char y;double z){} //没有重载，因为和原函数一样。

b．

int show(int a;duoble c;char b){} //重载了，因为参数类型不同。注意：重载和返回值类型没关系。

c.

void show(int a;douible c;char b){}   //重载了，因为参数类型不同，注意，重载和返回值类型没有关系。

d．

boolean show(int c;char b){}     //重载了，因为参数个数不同。

f.

double show(int x;char y;double z){}              //没有，这个函数不可以和给定函数同时存在于一个类中。

 

下面用示例演示：

class FunctionOverload

{

      public staticvoid main(String[] args)

      {

             System.out.print99();

}

public static void print99(int num)

{

      for(intx = 1;x<=num;x++)

      {

             for(inty =1;y<=x;y++)

             {

                    System.out.print(y+”*”+x+”=”+y*x+”\t”);

}

}

System.out.println();

}

public static void print()

{

      print99(9);

}

public static int add(int x,int y)

{

             returnx+y;

}

}

 

定义数组：[]

数组的定义：同一种类型数据的集合，其实数组就是一个容器。

数组的好处：可以自动给数组中的元素从0开始编写，方便操作这些元素。

格式1：元素类型[]数组名 = new 元素类型[元素个数或数组长度];

      示例：int[]arr = new int[]{1,3,5,7,8,9,6,3,6,9,85,63};

格式2；元素类型[]数组名 = new 元素类型[]{元素，元素……….};

int[] arr = new int[]{5,36,8,95,6};

int [] arr = {,6,8,9,6,5,2};

 

内存结构

java程序在运行时，需要在内存中分配空间。为了提高运输效率，有对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

栈内存:1.数组和对象，通过new建立的实例都存放在堆内存中。2.每一个实体都是内存地址值。3.实体中的变量都有默认初始化值。4.实体在被使用，会在不确定的时间内被垃圾回收器回收。

class ArrayDemo

{

      public staticvoid main(String[] args

      {

             int[]arr = new int [2];

             intarr[]=new int[2];

             int[]arr=new int[]{3,5,8,7,5,2};

             int []arr = {1,3,4,5,8,7,9,5};

             int []arr = new int{5};

             arr =null;

             System.out.println(arr[3]);

//ArrayIndexOutOfBoundsException:3表示：操作数组时，访问到了数组中不存在角标。

//NullPointerException :空指针异常，当引用没有任何指向为null的情况，该引用还在于用于操作实体。

      }

      

}

class ArrayDemo1

{

      public staticvoid main(String[] args)

      {

             //数组的操作，获取数组中的元素，通常会用到遍历。

             //数组中有个属性可以直接获取数组元素个数，即 length。

             //使用方式：数组名称。length  例如：int[] arr = new int[3];

             int[]arr = {3,4,8,9,6,8,7};

      System.out.println(“length=”+arr.length);

      for(int x = 0;x<arr.length;x++)

      {

             System.out.println(“Arr[“+x+”]=”+arr[x]+”;”);

}

}

//定义功能，用于打印数组中的元素，元素间用逗号隔开。

public static void printArray(int[] arr)

{

      System.out.print(“[”);

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

      {

             if(x!=arr.length-1)

                    System.out.print(arr[x]+”,”);

}

System.out.print();

}

}

 

有时可能在打印后会出现“[i@de6ced”，这是直接打印出来了数组的地址。用的是16进制。

排序问题

需求：对给定数组{5,3,6,9,8,7,5,2,4}

class Array

{

 

      /*

      选择排序，内循环结束一次，最值出现在头角标位置上。   

      */    

 

      public staticvoid selectSort(int[] arr)  

      {

             for(intx = 0;x<arr.length-1;x++)

             {

                 for(int y=x+1;y<arr.length;y++)

                 {

                    if(arr[x]>arr[y])

                    {

                           

                           

                           

                           inttemp = arr[x];

                           arr[x]=arr[y];

                           arr[y]=temp;

                           

                           

                           

                           //swap(arr,x,y);

                    }

                   }

             

             }

             

      }

/*

冒泡排序

*/

public static voidbubbleSort(int[] arr)

{

      for(intx=0;x<arr.length-1;x++)

      {

             for(inty =0 ;y<arr.length-x-1;y++)  // -x的原因：让每次比较的元素减少，-1：避免角标越界。

             {

                    if(arr[y]<arr[y+1])

                    {

                           inttemp = arr[y];

                           arr[y]= arr {y+1};

                           arr[y+1]=temp;

}

}

}

}

      /*

      无论什么排序。都需要对满足条件的元素进行位置置换。

      所以可以这部分相同的代码提取出来，单独封装成一个函数。   

      */

      

      public staticvoid main(String[] args)

      {

             int[]arr ={5,3,6,9,8,7,5,2,4};

             //排序前；

             printArray(arr);

             //排序

             selectSort(arr);

 

             //Arrays.sort(arr);//这句代码是java中已经定义好的一种排序方式，开发中，用此语句。

             //排序后

             printArray(arr);

      }

      

      public staticvoid printArray(int[] arr)

      {

             System.out.print("[");

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

             {

                    if(x!=arr.length-1)

                           System.out.print(arr[x]+",");

                    else

 

                           System.out.println(arr[x]+"]");

             }

      }

 

}     

 

面向对象

面向对象是相对面向过程而言。面向对象和面向过程都是一种思想。

面向过程——强调的是功能行为。面向对象——将功能封装进行对象，强调具备了功能的对象。

面向对象是基于面向过程的。

例如：本人不懂电脑配置，但可以找个熟悉电脑配置的人A去和自己一起买，这样就使买电脑的过程从复杂到简单了。具体A怎么和卖家去谈电脑不用管，自己可以买到配置理想的电脑就行了。这个过程就使得自己的买电脑过程变得简单了。我使用的就是A的懂电脑的功能，具体的功能在A里封装，不用去研究他。

软件公司招人去干活，也是为了提高效率。

分两部分：思想，对象。

再看一个例子：人开门。

可以用一下图示：

人

{

      开（门）

      {

             门、开{}；

}

}

门

{

      开{}{}；

}

面向对象：三个特征；封装，继承，多态。

开发软件，其实就是找对象使用，没有对象，就创建一个对象。

找对象，建立对象，使用对象，维护对象的关系。

类和对象的关系

张三、李四：现实生活中的对象。想要描述，提取对象中共性内容，对具体的抽象。描述时，这些对象中共性内容有：姓名，年龄，性别，学习的功能。

映射到java中，描述就是class定义的类。具体对象就是对应java在堆内存中用new建立实体。

类：就是对现实生活中事物的一个描述。对象：就是这类事物，实实在在的个体。

比如，有这么个需求，然后用类和对象表达出来。

需求：描述一个汽车。描述事物其实就是描述事物的属性和行为。属性对应是类中变量，行为对应的类中的函数（方法）。其实定义类，就是在描述事物，就是在定义属性和行为，属性和行为共同成为类中的成员（成员变量和成员方法）。

class Car

{

      //描述颜色

      String color= “红色”;

      //描述轮胎

      int num = 4;

      //运行行为

      void  run()

      {

             System.out.println(color+”, ,”+num);

}

}

class CarDemo

{

      public staticvoid main(String[] args)

      {

             //生产汽车，在java中通过new操作符来完成。

             //其实就是在堆内存产生一个实体。

             Car c= new Car();   // c就是一个类类型变量，类类型变量指向实体。

             //需求，将已有的颜色改变蓝色，指挥该对象做使用。在java指挥方式是：对象.对象成员

             c.car= “blue”,

             c.run();

             Car c1= new Car();

             c1.run();//red 4;

 

      Car c = newCar ();

      c.num = 5;

可以写成 new Car().num = 5

             newCar().color = “blue”;

             newCar().run();

             

}

}

成员变量和局部变量：成员变量作用于整个类中，局部变量作用于函数中，或者语句中。

在内存中的位置：a.成员变量:在堆内存中，因为对象的存在，才在内存中存在。b.局部变量：存在栈内存中。

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

使用方式：一、当对对象的方法只调用一次时，可以用匿名对象来完成，这样比较简化。如果对一个对象进行对个成员调用，必须给这个对象起个名字。二、可以将匿名对象作为实际参数进行传递。

 

需求：汽车修配厂对汽车进行改装，将来的车改成黑车，三个轮胎。

public static void show(Car c){

     c.num = 3;

      c.color = “blue”;

}

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

好处：将变化隔离、便于使用、提高复用性、提高安全性。封装原装：将不需要对外提供到的内容隐藏起来。

把属性都隐藏，提供公共方法对其访问。需要注意的是，私有仅仅是封装的一种表现形式。

private：私有，权限修饰符，用于修饰类中的成员（成员变量，成员函数）。之所以对外提供访问方式，就是因为可以在访问方式中加入逻辑判断等语句。对访问的数据进行操作，提高代码健壮性。

class Person

{

      private intage;

      public voidsetAge(int a)

      {

             age=a;

}

}

class PersonDemo

{

      public staticvoid main(String [] args)

      {

             Personp = new Person();

             p.age= 20;

             p.age(20);

             p.speack();

}

}

构造函数:1.函数名与类名相同。2.不用定义返回值类型。3.不可以写return语句。

对象一建立就用调用与之对应的构造函数。

构造函数的作用：可以用于给对象进行初始化。

class Person

{

      Person()

      {

             System.out.println(“person  run”);

}

class PersonDemo2

{

      publicstatic void main(String[] args)

      {

             Personp = new Person();

             newPerson();

}

}

}

构造函数特点：1.函数名与类名相同。2.不用定义返回值类型。3.不可以写return语句。

作用：给对象进行初始化。需要注意的是：1.默认构造函数的特点。2.多个函数是以重载的形式存在的。

class Person

{

      Person

{

             System.out.println(“personrun”);

}

}

对象一建立就会用与之对应的构造函数。构造函数的作用，可以用于给对象初始化。当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数。当在类中自定义了构造函数后，默认的构造函数就没有了。构造函数和一般函数在写法上有不同。在运行上也有不同。构造函数是在对象一建立就运行，给对象初始化。而一般方法是对象调用才执行，给是对象添加对象具备的功能。

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

当分析事物时，该事物存在具备一些特征性或者行为，那么将这些内容定义在构造函数中。

class Person

{

      privateString name;

      private intage;

      Person()

      {

             System.out.println(“A:name=”+name+”,Age=”+age);

}

Person(String n)

{     

      name= n;

      System.out.println(“A:name=”+name+”,age=”+age);

}

}

this:看上去，是用于区分局部变量和成员变量同名的情况。就代表本类的对象，到底代表哪一个呢？this代表它所在函数所属对象的引用。哪个对象在调用this所在的函数，就代表哪个函数。this语句用于构造函数之间相互调用。this语句只能定义在构造函数的第一行。

class Person

{

      private Stingname;

      private intage;

      Person(Stringname)

      {

             this.name= name;

}

      Person(Stringn,int a)

      {

             name= a;

             age= a;

}

public void speak()

{

      System.out.println(“name=”+name+”,age=”+age);

}

}

class Person4

{

      public staticvoid main(String[] args)

      {

             Personp = new Person(“ls”);

             p.speak();

}

/*

需求：给人定义一个用于比较年龄是否相同的功能，也就是是否是同龄人。

*/

public boolean compare(Person p)

{

      returnthis.age==p.age;     

}

}

class PersonDemo3

{

      public staticvoid main(String[] args)

      {

             Personp1 = new Person(32);

             Personp2 = new Person(45);

             booleanb = new Person(b);

             System.out.println(b);

}

class PersonDemo4

{

      public staticvoid main(String[] args)

      {

             Personp = new Person(“lisi”,30);

             Personp1 = new Person(“lis2”,45);

}

}

}