Java自学开工第二周

于 2021-05-20 15:39:51 发布
阅读量168 收藏
点赞数
分类专栏： 笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51461448/article/details/117077845
版权

第四章：流程控制 

与C语言及其他语言相同，Java语言的复合语句是以整个块区为单位的语句，所以又称为块语句。复合语句由开括号“{”开始，闭括号“}”结束。

1.if条件语句： 

虽然if后面的复合语句只有一条语句，省略“{ }”并无语法错误，但是为了增强程序的可读性最好不要省略。

例：给定一个整数，判断它能否被3，5，7整除。

package myproject;
public class my {
public static void main(String[] args) {
	int a=105;
	if(a%3==0)
	{ System.out.println(a+"能被3整除");}
	if(a%5==0)
	{ System.out.println(a+"能被5整除");}
	if(a%7==0)
	{ System.out.println(a+"能被7整除");}
	if(a%3!=0&&a%5!=0&&a%7!=0)
	{ System.out.println("不能被3，5，7中任何一个数整除");}
	                                   }
}
/*输出：
105能被3整除
105能被5整除
105能被7整除
*/

2.if...else if多分支语句：

编辑时要注意语句序列

例：一个最简单的计算器，支持+, -, *, / 四种运算。仅需考虑输入输出为整数的情况，数据和运算结果不会超过int表示的范围。

package myproject;
public class my {
public static void main(String[] args) {
	char x='*';
	int a=5,b=4;
	if(x=='+')
	{ System.out.println("a+b="+(a+b));}
	else
	{ if(x=='-')
	{ System.out.println("a-b="+(a-b));}
	   else 
	   { if(x=='*')
       { System.out.println("a*b="+(a*b));}
	      else 
	      { if(x=='/')
	      { if(b==0)
	      { System.out.println("Divided by zero!");}
	          else
	          { System.out.println("a/b="+(a/b));}
	          }
	              else
		          { System.out.println("Invalid operator!");}
		        }
		    }
		}
	}
}
/*输出：
a*b=20
*/

3.switch多分支语句：

在switch语句中，case语句后常量表达式的值可以为整数，但绝不可以是实数。

例：晶晶的朋友贝贝约晶晶下周一起去看展览，但晶晶每周的1、3、5有课必须上课，判断她能否接受贝贝的邀请。

package myproject;
public class my {
public static void main(String[] args) {
  int a=7;
  switch(a)
 {
   case 1:case 3:case 5:
   System.out.println("不能一起去看展览");
   case 2:case 4:case 6:case 7:
   System.out.println("可以一起去看展览");
  }
  }
}
/*输出：
可以一起去看展览
*/

4.while语句与do......while语句：do......while语句与while语句的一个明显区别是，do......while语句在结尾处多了一个分号。

例：两者的比较

package myproject;
public class my {
public static void main(String[] args) {
	int a=100;
    while(a==60)
   {
	 System.out.println("OK1");
     a--;
   }
    int b=100;
    do {
    	System.out.println("OK2");
    	b--;
    }while(b==60);
}
}
    

/*输出：
OK2
*/

5.for循环语句：

不过多解释，直接举例：

例：输入n，输出一个n*n的正方形，正方形由符号c1和c2组成，正方形的四条边和对角线由c1组成，其余部分由c2组成。

在此过程中由于System.out.println( )涉及换行，而该程序部分并不需要换行。所以搜集了相关知识：
Java常用的输出语句有下面三种：
System.out.println(222);换行打印，输出之后会自动换行
System.out.print(222);不换行打印
System.out.printf("分数是：%d",88);按格式输出

package myproject;
public class my {
public static void main(String[] args) {
	int n=9;
    char c1='+',c2='-';
    for(int i=1;i<=n;i++)
    {System.out.print(c1);}  //不换行
     System.out.println("");  //换行
    for(int a=2,b=n-1;a<=n-1&&b>1;a++,b--)
    {
    	System.out.print(c1);
        for(int c=2;c<=n-1;c++)
        {
            if(c==a||c==b)
           System.out.print(c1);
            else System.out.print(c2);
        }
        System.out.println(c1);
    }
    for(int i=1;i<=n;i++)
    {System.out.print(c1);}
}
}
    

/* 输出：
+++++++++
++-----++
+-+---+-+
+--+-+--+
+---+---+
+--+-+--+
+-+---+-+
++-----++
+++++++++
*/

例：求两个正整数的最小公倍数。（0<n<10000，0<m<10000)

C++中的max()，min()，abs()数据库函数与Java中的调用不同，Java需要类如Math.max(a,b)，Math.min(a,b)直接说明数据库。

package myproject;
public class my {
public static void main(String[] args) {
	int a=10,b=13,i,n,min1=0,max1;
    int c=Math.max(a,b); //函数调用
    int d=Math.min(a,b);
    for(i=1;i<=50;i++)
    {
        if(d==0)
            min1=c;
        else
        {
            n=d;
            d=c%d;
            c=n;
        }
    }
    max1=a*b/min1;
    {System.out.print(max1);}
}
}
    

/* 输出：
130
*/

6.foreach语句（for语句的特殊简化版本，不能完全取代for语句，但是任何foreach语句都可以修改成为for语句）

7.break语句（跳出switch结构和当前循环体）

break标签名：带有标签的break可以指定跳出的循环，这个循环可以是内层循环，也可以是外层循环。例：

package myproject;
public class my {
public static void main(String[] args) {
	Loop:for(int i=0;i<3;i++) {
		for(int j=0;j<6;j++) {
			if(j==4) {
				break Loop; //直接跳出两层循环
			}
			System.out.println("i="+i+" j="+j);
		}
	}
}
}
    
/* 输出：
i=0 j=0
i=0 j=1
i=0 j=2
i=0 j=3
*/

8.continue语句（同样也有continue标签名）

第五章：数组

1.一维数组的创建、初始化与使用：

创建与初始化(与C++有些许不同）：先声明，再用new运算符进行内存分配。

例：int month[]=new int[]{1,2,3};int month[]=new int[4];(使用new关键字为数组分配内存时，整型数组中的各个元素的初始值都为0。）

例：给定两个n维向量a=(a1,a2,...,an)和b=(b1,b2,...,bn)，求点积a·b=a1b1+a2b2+...+anbn。

package myproject;
public class my {
public static void main(String[] args) {
	 int n=3,x=0;
	 int a[]=new int[]{1,2,3,4};
	 int b[]=new int[]{4,3,2,1};
	    for (int i=0; i<=n; i++){
	        x=a[i]*b[i]+x;
	    }
	    System.out.println("两个4维向量的点积="+x);
	}
}
    
/* 输出：
两个4维向量的点积=20
*/

2.二维数组的创建、初始化与使用：

例：int myarr[]={{12,0}{45,10}};(初始化二维数组后，要明确数组的下标都是从0开始，例如上面代码中myarr[1][1]的值为10。）

（1）遍历数组：获取数组中的每一个元素

package myproject;
public class my {
public static void main(String[] args) {
	 int a[][]= new int[][] {{1},{2, 3} ,{4,5,6}};
	 for (int k= 0;k < a.length; k++)
	    for (int c=0;c<a[k].length; c++)
	    	{
	    	System.out. print(a[k][c]);
	    	}
	    	System.out. println();
	    	}
	}
    
/* 输出：
123456
*/

（2）填充与替换数组：import.java.Arrays;//要引入Java.util.Arrays类

fill(int[]a, int fromIndex, int toIndex, int value)

a:要进行填充的数组
fromIndex:要是用指定值填充的第一个元素索引（包括）
toindex:要使用指定值填充的最后一个元素的索引（不包括）
value:要存储在数组的所有元素的值

填充：

package myproject;//填充
import java.util.Arrays; 
public class my {
public static void main(String[] args){
	int a[] = new int[5]; 
	int b[] = {1,2,3,4,5};
	for(int i = 0; i < b.length; i++){
		Arrays.fill(a,i,i+1,b[i]);
	}
	for(int j = 0; j < a.length; j++){
		System.out.println("第"+j+"个元素是："+a[j]);
	}
}
}
  
/* 输出：
第0个元素是：1
第1个元素是：2
第2个元素是：3
第3个元素是：4
第4个元素是：5
*/

替换：

package myproject;//替换
import java.util.Arrays; 
public class my {
public static void main(String[] args){
	int arr[] = new int[] {99,88,77,66,55,44,33,22,11};
	Arrays.fill(arr,1,3,1000);
	Arrays.fill(arr,5,6,1000);
	for(int i = 0;i<arr.length;i++)
	System.out.println("第"+i+"个元素是："+ arr[i]);
	}
}
/* 输出：
第0个元素是：99
第1个元素是：1000
第2个元素是：1000
第3个元素是：66
第4个元素是：55
第5个元素是：1000
第6个元素是：33
第7个元素是：22
第8个元素是：11
*/

3.排序：Arrays.sort(object)(数字排在字母前面，以小到大，大写字母排在小写字母前面）

4.复制数组：copyOf(arr,int newlength)或copyOfRange(int fromindex,int toindex)

int b[] = Arrays.copyOfRange(a, 0, 20);

int c[] = Arrays.copyOf(a, 10);

5.数组排序：

冒泡排序法：

package myproject; 
public class my {
public static void main(String[] args){
	int a[]= {45,98,50,12,51,61,2,10};
	my sorter=new  my();
	sorter.sort(a);
}

public void sort(int a[]) {
	for(int i=1;i<a.length;i++) {
		for(int j=0;j<a.length-i;j++){
			if(a[j]>a[j+1]) {
				int temp=a[j];
				a[j]=a[j+1];
				a[j+1]=temp;
			}
		}
	}
		showArray(a);
	}
public void showArray(int[] a) {
	for(int i:a) {
		System.out.print(" "+i);
	}
}
}
/* 输出：
 2 10 12 45 50 51 61 98
*/

第六章：类与对象

1.面对对象

面向对象是已对象为基础，完成各种操作主要强调对象。

特点：面向对象是一种常见的思想，比较符合人们的思考习惯；可以将复杂的业务逻辑简单化，增强代码复用性；具有抽象、封装、继承、多态等特性。

2.类：（成员变量，成员方法，this关键字，构造方法）

package myproject;
public class Book {
	private String name;        //定义一一个String型的成员变量
	
    public String getName(){    //定义一个getName()方法
	int id= 0;                  //局部变量
    setName("Java");            //调用类中其他方法
    return id + this.name;      //设置方法返回值
	}
                              
private void setName(String name){   //定义一个setName()方法
	this.name = name;}              //将参数值赋予类中的成员变量

public Book getBook() {
	return this;                   //返回Book类引用
	}
}

3.静态变量、常量和方法

package myproject;
public class Book {
 static double PI=3.141592;
 static int id;
 public static void method1() {
	 //doing something
 }
 public static void method2() {
	 System.out.println(Book.PI);
	 System.out.println(Book.id);
	 Book.method1();
 }
 public static void method3() {
	 method2();
		    }
}

在静态方法中不可以使用this关键字，不可以直接调用非静态方法。

不能将方法体内的局部变量声明为static。例：

public class Book {
public static void method1() {
static int i=0;
      }
}

如果在执行类时，希望先执行类的初始化动作，可以使用static定义一个静态区域。例如：当这段代码被执行时，首先执行的是static块中的程序，并且只会执行一次。

public class Book {
static {
       //some
    }
}

4.类的主方法

主方法是静态的， 所以如要直接在主方法中调用其他方法，则该方法必须也是静态的。主方法没有返回值。
主方法的形参为数组。其中args[0]~args[n]分别代表程序的第一个参数到第n个参数，可以使用args.length获取参数的个数。

5.对象
创建：Test test=new Test[];或Test test=new Test["a"];

引用：Book book=new book();

访问对象的属性与行为：

package myproject;
public class no {
	int i=6;
public void call() {
	for(i=1;i<=6;i++)
	{
		System.out.print(i+"不学了 ");
	if(i==6) {
		System.out.println("\n");
	}
}
}
public no() {}
public static void main(String[] args) {
	no t1=new no();
	no t2=new no();
	t2.i=7;
	System.out.println("偷懒几天:"+t1.i++);
	t1.call();
	System.out.println("星期几偷懒:"+t1.i);	
	t2.call();
		    }
}
/*输出
偷懒几天:6
1不学了 2不学了 3不学了 4不学了 5不学了 6不学了 

星期几偷懒:7
1不学了 2不学了 3不学了 4不学了 5不学了 6不学了
*/

对象的销毁：

Java提供垃圾回收机制可以判断对象是否还在使用，并能够自动销毁不再使用的对象，释放所占用的资源。因此我们只管创建对象，不需要考虑销毁对象。

对象被当作垃圾回收：

Object e= new Object(); // 对象o的作用范围，超过这个范围对象将被视为垃圾

Object e= new Object();e=null; // 对象被赋值为null将被视为垃圾

在java的Object类当中，提供了一个protected类型的finalize()方法，在垃圾回收时，首先会调用此方法。在下一次垃圾回收动作发生时，才真正回收被对象占用的内存。

最后测试一个图书类的展示：

package myproject;
public class Book {
	    private String name;  
	    private double price;  
	    private int storage;  
	    public Book(String name, double price, int storage) {
	        this.name = name;
	        this.price = price;
	        this.storage = storage;
	    }
	    public void getName() {
	    	System.out.print("书名:"+name+" ");
	    }
	    public void getPrice() {
	    	System.out.print("价格:"+price+" ");
	    }
	    public void getStorage() {
	    	System.out.println("存货:"+storage);;
	    }
public static void main(String[] args) {
	Book a=new Book("如何学好Java", 1000,100);
	Book b=new Book("山东菏泽曹县", 1000000,10);
	a.getName();a.getPrice();a.getStorage();
	b.getName();b.getPrice();b.getStorage();
}
}

/*输出
书名:如何学好Java 价格:1000.0 存货:100
书名:山东菏泽曹县 价格:1000000.0 存货:10
*/

 

已经是一条咸鱼了
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值