“黑马程序员”学习笔记四

最新推荐文章于 2023-09-22 20:33:49 发布

gbdnf

最新推荐文章于 2023-09-22 20:33:49 发布

阅读量347

点赞数

本文链接：https://blog.csdn.net/gbdnf/article/details/8881905

版权

------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------

/*循环语句：while(条件语句){执行语句；}先判断再执行
* do{执行语句；}while(条件语句)；先执行一次再判断，满足条件再执行do
* for(定义变量；条件语句；自增或自减){执行语句；}重点：for语句中定义的
* 变量只在for 语句中有效
* */

public class MingTian1
{
public static void main(String[] args)
{int x=1;
while (x<3)//循环语句
{
  System.out.println("x="+x);
  x++;//如果没有“x++；”语句运行会一直打印x=1
}
for(int a=1;a<=9;a++)
{for(int b=1;b<=a;b++)
  {
  System.out.print(b+"*"+a+"="+a*b+"\t" );
  //输出语句里面一定要注意连接符“+”和字符串“”的应用
  }
  System.out.println();
}
int m=1;
for (System.out.println("a");m<3;System.out.println("b"));
{
   System.out.println("c");
  m++;//运行结果是acbcb,条件语句必须有真假否则编译不能通过
}//int x=1;for( ;x<5; ){x++;}这是正确的代码
}
/*break:可以用在switch和循环语句中，表示跳出当前循环
* w:for(int x=0;x<3;x++)
* {q:for(int y=0;y<3;y++)
* { System.out.println("x="x);
* //break;指的是跳出当前循环也等于break q;
* //break w;指的是跳出外循环
* }
* }
* continue:只能用于循环结构，结束本次循环，继续下次循环
* for(int x=0;x<3;x++)
* {if(x%2==1)
* continue;
*   System.out.println(x);输出的结果是0 2
* }
*/
}

/*
* 函数：就是能够实现一定功能的一段小程序，函数就是方法，方法就是函数；
* 函数的格式：
* 修饰符，返回值类型，函数名（参数类型，形式参数1，形式参数2，形式参数3）
* {
* 执行语句；
* return返回值；
* }
* 函数重载：在同一个类中允许存在两个或两个以上的同名函数；但是参数必须不同，另外最重要的是
* 函数重载和返回值类型无关（函数名最好起得有意义一点）。
* 什么时候使用重载呢？当定义的功能相同，但参与运算的未知内容不同时，就使用重载，定义相同
* 名称的函数。
*
* */
public class MingTian2
{
public static void main(String[] args)
{
  //int x = getResult(4);
   //System.out.println(x);
  getResult(4);


  int m=getSum(4,7);
  System.out.println(m);
}
public static void getResult(int num)
{
  //return num*3+5;
  //void表示没有具体返回值，上面的return;可以省略不写

  System.out.println(num*3+5);
}

static int getSum(int a,int j)
{
  return a=j;
}
}

/*需求：封装一个打印矩形的功能并用分隔线隔开
*思想：需要用到for嵌套循环并且须定义两个变量
*注意：因为是直接打印的，所以没有返回值类型，所以用void
*/

public class HanShuLianXi
{
public static void main(String[] args)
{
  juXing(4,7);
  daYin();
  juXing(9,3);
  daYin();
}
public static void juXing(int a, int b)
{
  for (int x=0;x<a;x++)
  {
   for (int y=0;y<b;y++)
   {
    System.out.print("*");
   }
   System.out.println();
  }

}
public static void daYin()
{
  System.out.println("_________________");
}
}

/*数组：是同一种数据类型的集合，可以自动的给数组中的元素从0开始编号
* 格式1：元素类型[] 数组名=new 元素类型【元素个数或长度】
* 如：int[] arr=new int[5];
* 格式2：元素类型【】数组名=new 元素类型【】{1，3，5，7，9}；
* 如：int[] arr=new int[]{1,3,5,7,9};
* 或：ing[] arr={1,3,5};
* new:关键字，在堆内存中产生一个容器实体，并把数据存进内存
* int[] x=new[3];其中的x代表的是int[]数组（x是引用数据类型）
* x=new[3]其实是把new[3]在堆内存中的地址值赋给x
* int[]在堆内存中任意角标位的默认值都是0
* double[]在堆内存中任意角标位的默认值都是0.0
* float[]在堆内存中任意角标位的默认值都是0.0f
* boolean[]在堆内存中任意角标位的默认值都是false
* 数组名.length:表示数组中的成员个数也就是数组长度
* */

public class MingTian3
{
public static void main(String[] args)
{
  int[] k={12,5,9,7,6,5,6,7,3};
  printArray(k);
  printMax(k);
  printMin(k);
  paiXv(k);
  paiXi_2(k);
  /*int arr[]=new int [6];
  int[]x=new int []{1,3,5,7};
  int[] y={2,4,6,8};
  System.out.println(x.length);
  System.out.println(y.length);
  for(int t=0;t<x.length;t++)
  {
  System.out.println("x["+t+"]"+"="+x[t]);
  }*/
  /*求数组y[]的所有元素的和
  int sum=0;
  for (int a=0;a<y.length;a++)
  {
   sum+=y[a];
  }
  System.out.println(sum);
  */
}
//打印一个数组的所有元素并用“，”隔开
public static void printArray(int[] arr)
{
  for(int x=0;x<arr.length;x++)
  {
   if(x!=arr.length-1)
    System.out.print(arr[x]+"，");
   else
    System.out.println(arr[x]);
  }
}
//找出数组最大值并打印
public static void printMax(int[] j)
{
  int max=j[0];
  for(int y=1;y<j.length;y++)
  {
   if (j[y]>max)
    max=j[y];
  }
  System.out.println(max);
  }
  //找出数组中的最小数并打印
public static void printMin(int[] arr)
{
  int min=0;
  for(int b=1;b<arr.length;b++)
  {
   if(arr[b]<arr[min])
    min=b;
  }
   System.out.println(arr[min]);
}
//选择排序
public static void paiXv(int[] t)
{
  for(int a=0;a<t.length;a++)
  {
   for(int z=1+a;z<t.length;z++)
   {
   if(t[a]>t[z])
    { int s=0;
     s=t[a];
     t[a]=t[z];
     t[z]=s;
    }
   }
   if(a!=t.length-1)
    System.out.print(t[a]+",");
   else
    System.out.println(t[a]);

  }
}
//冒泡排序
public static void paiXi_2(int[] j)
{
  for(int x=0;x<j.length;x++)
  {
   for(int y=1;y<j.length-x;y++)
   {
    if(j[y-1]>j[y])
    { int s=0;
      s=j[y];
      j[y]=j[y-1];
      j[y-1]=s;
    }
   }
   if(x!=j.length-1)
    System.out.print(j[j.length-x-1]+".");
   else
    System.out.println(j[j.length-x-1]);
  }
}

/*换位功能封装
public static void huanWei(int[] arr,int a,int b)
{
   int m=arr[a];
   arr[a]=arr[b];
   arr[b]=m;
}
*/
}

public class MingTian4
{

/**
*查找和折半查找(折半查找的数组必须是有序的)
*/
public static void main(String[] args)
{
  int[] k={15,6,9,8,9,7,4,5,6,4};
  int[] j={1,5,9,11,15,17,49};
  int index=getIndex(k,4);
  System.out.println("index="+index);
  int index_1=getIndex(j,16);
  System.out.println("index_1="+index_1);
  //toBin(6);
  zhuanHuan_2(60);
}
public static int getIndex(int[] arr,int t)
{
  for(int x=0;x<arr.length;x++)
  {
   if(arr[x]==t)
    return x;
  }
   return -1;
}
public static int halfSearch(int[] arr,int m)
{
  int min,mid,max;
  min=0;
  max=arr.length-1;
  mid=(min+max)/2;
  while(m!=arr[mid])
  {
   if(m>arr[mid])
    min=mid+1;
   else if(m<arr[mid])
    max=mid-1;
   mid=(min+max)/2;
   if(min>mid)
    return -1;
  }
  return mid;
}
//十进制转二进制
public static void toBin(int x)
{
  StringBuffer sb=new StringBuffer();
  while(x>0)
  {
   sb.append(x%2);
   x=x/2;
  }
  System.out.print(sb.reverse());
}
//十进制转换为十六进制
public static void zhuanHuan_1(int z)
{
  StringBuffer sb=new StringBuffer();
  for(int y=0;y<8;y++)
   {
   int num=z&15;
   z=z>>>4;
   if(num<10)
    sb.append(num);
   else
    sb.append((char)(num-10+'A'));
   }
  System.out.print(sb.reverse());
}
public static void zhuanHuan_2(int j)
{
  char[] k={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
  while ( j!=0)
  {
   int num=j&15;
   j=j>>>4;
   System.out.print(k[num]);
  }
}
}

public class MingTian5
{static
{
System.out.print("b");
}

/**
static的用法：可以用来修饰成员变量和成员函数
  什么时候使用static呢？
  当成员变量是所有对象所特有的时候，也就是所定义的变量是对象
  的共有属性是前面加静态修饰
  当对象函数没有访问到非静态成员时，可以加静态修饰
  //对象是用来封装数据的，当一个类中的方法没有用到其特有数据时
  //我们可以不用建立对象，直接用类名调用，但是类名前必须加static修饰
  1.被静态修饰的成员可以直接被类名调用（还可以被对象调用）
  2.静态成员随着类的加载而加载随着类的消失而消失并优先于对象存在
  3.静态成员被所有对象共享
类变量和实例变量的区别：
  类变量存在于方法区中随着类的加载而加载，随着类的消失而消失
  实例变量随着对象的建立而存在于堆内存中，随着对象的消失而消失
*/
public static void main(String[] args)
{ new Demo();
  new Demo();
  System.out.print("over");

}
static
{
System.out.print("c");
}

}
class Demo
{static
{
System.out.print("a");
}

}/**说明书的提取用的是javadoc工具
如：javadoc -d 说明书存放目录 -author -version 原文件名.java
须生成说明是的类前面必须加public修饰，其默认构造函数的和类的权限一样
也要加public
*/

public class MingTian6
{

/**注意：私有仅仅是封装的一种表象形式，只要权限不在我访问范围之内，对我
* 来说都算是封装
1，私有之后的调用:set***()方法是建立该私有成员变量（局部
变量前面不能加任何修饰词，无法私有）无返回值类型所以前面加void
get***()方法是获取该私有成员变量，返回值类型和原有返回值类型一致
  2，构造函数和构造代码块:构造代码块是在类中由“{}”括起来的一部
  分代码，括号前没有任何名称和修饰
   构造函数是名称与类名完全一样的函数，作用是对该类进行初始化
   ：class Person
   {
    person()
    {}
   }
   代码运算优先等级：静态代码块，构造代码块，构造函数
在构造函数中可以用this()语句来相互调用，this()语句必须放在构造函数第一行
如：class Person
{
int name;
int age;
person(String name)
{
  this.name=name;
}
person(String name,int age)
{
  this(name);//this(name)调用person(String name)
  this.age=age;
}
}
    */
public static void main(String[] args)
{ person p=new person();
  person p1=new person();
  p.setName("zhang san");
  p.setAge(21);
  p.print();
  System.out.println(p.getName());
  System.out.println(p.getAge());
  //注意：set***()和get***()用法是不同的
  p1.setAge(25);
  boolean b=p.compare(p1);
  //System.out.println(p.compare(p1));
  System.out.println(b);
}

}
class person
{
private String name;
private int age;
public void setName(String name)
{
  this.name=name;
}
public void setAge(int age)
{
  this.age=age;
}
public String getName()
{
  return name;
}
public int getAge()
{
  return age;
}
void print()
{
  if(age>0)
  System.out.println("name="+name+", age="+age);
  else
   System.out.println("name="+name+"非法数据");
}
boolean compare(person p)
{
  return this.age==p.age;//注意this的用法
}
}