Java基础知识难点总结

目录

          • 1.final关键字
          • 2.布尔类型
          • 3.取余运算符
          • 4.foreach循环
          • 5. & 和 &&,| 和 || 的关系
          • 6.一位数组
          • 7.随机数
          • 8.二维数组
          • 9.null的使用
          • 10.对象的比较( "=="运算符 和 equals()方法的区别 )
          • 11.构造方法
          • 12.代码块
            • 1)普通代码块
            • 2)构造代码块
            • 3)静态代码块

1.final关键字

在java语言中主要用关键字final来定义常量。

必须要在常量声明时对其进行初始化
final关键字可以修饰基本数据类型,对象应用和方法
被final修饰后无法再对变量进行修改

//@Description: Java中定义常量
public class TestFinal
{
     
  static final int YEAR = 365; //一个静态常量,常量用大写字母表示
  public static void main(String[] args)
  {
     
    System.out.println("两年是: " + 2 * YEAR + "天");
  }
}
//上面代码的结果如下
两年是: 730天
2.布尔类型

在Java中用关键字boolean来声明布尔类型
被声明为布尔类型的变量,只能用true和false来进行赋值
不能用1和0分别代表true和false
布尔类型不可能与其他任何数据类型进行转换

public class booleanDemo
{
     
 public static void main(String[] args)
 {
     
    boolean Zhang = true;
    System.out.println("Zhang is man? = " + Zhang);
 }
}
//上面代码的结果如下
Zhang is man? = true 
3.取余运算符
5 % 3 = 2
5 % -3 = 2
5.2 % 3.1 = 2.1
3 % 5 = 3
4.foreach循环

虽然说得是foreach循环但用的时候用的还是for关键字,只是为了与for循环区分开来而已

public class foreachDemo
{
     
  public static void main(String[] args)
  {
     
     int[] numArray = {
     1,2,3,4,5,6};
     for(int i = 0;i < numArray.length;i++){
     
         System.out.print(numArray[i] + " ");
     }
     System.out.println();//换行
     System.out.println();//换行
     for(int element : numArray)
     {
     
     //element相当于自增下标的numArray[0],numArray[1]....
       System.out.print(element + " ");
      }
      System.out.println();
  }
}
//结果如下
1 2 3 4 5 6

1 2 3 4 5 6
5. & 和 &&,| 和 || 的关系

对于与操作,有一个条件不满足结果就是false
&
普通与(&)是,所有的判断条件都要执行;
&&
短路与(&&)是,如果前面有条件已经返回了false,不再往后判断,最终结果是false;

对于或操作,有一个条件满足结果就是true
|
普通或( | ),所有判断条件都要执行;
||
短路或( || ),如果前面有条件返回了true,不再向后判断,最终结果是true;

6.一位数组

可以把”int[ ]”在整体上看成一种数据类型,其他float[],double[]等也一样

//错误的定义方式如下
int arr[4] = {34,23,12,54};
int[] arr = {43,23,12,11};

//正确的定义方式如下
数据类型[] 数组名;//声明一位数组
数组名 = new 数据类型[个数]; //分配内存给数组
int[] arr;
arr = new int[4];

还可以这样
数据类型[] 数组名 = new 数据类型[个数];
int[] arr = new int[4];

也可以这样
int[] arr = {2,3,2,1};//编译器按照元素个数自动分配内存大小
7.随机数
import java.util.Random;
public class randomDemo
{
     
   public static void main(String[] args)
   {
     
       Random rand = new Random();//创建一个random对象
       int a = rand.nextInt(10);//返回[0,10)的随机整数
       int b = rand.nextInt()*10 + 1;//返回[0,10]的随机整数
   }
}

8.二维数组
//三种声明方式
//1
数据类型[][] 数组名;
数组名 = new 数据类型[行的个数][列的个数];
//2
数据类型[][] 数组名 = new 数据类型[行的个数][列的个数];
//3
数据类型[][] 数组名 = {
            {第0行初值},
            {第1行初值},
            ...
            {第n行初值},
 };
 int[][] num = {
   {2,3,32},
   {4,3,2}
};

每行的元素个数可以不同

//1
int[][] num = {
      {2,3,2,32},
      {2,3},
      {1,2,3,2,1,12,32}
};
//2
int[][] num = null;
num = new int[3][];
num[0] = new int[3];
num[1] = new int[10];
num[2] = new int[1];
9.null的使用

不可以将null赋给基本数据类型(如:int,float,double等)
比如,下面的形式是错误的:
int a = null;
下面的形式正确的:
Object a = null;//对象

10.对象的比较( "=="运算符 和 equals()方法的区别 )

1)"=="运算符用于比较两个对象的内存地址是否相等。
2)equals()方法用于比较两个对象的内容是否一样

public class CompareObject1
{
     
   public static void main(String[] args)
   {
     
      String str1 = new String("Java");
      String str2 = new String("Java");
      String str3 = str2;
      if(str1 == str2)
      {
     
         System.out.println("str1 == str2");
      }else{
     
         System.out.println("str1 != str2");
      }
      if(str2 == str3)
      {
     
         System.out.println("str2 == str3");
      }else{
     
         System.out.println("str2 != str3");
      }
   }
}

输出结果如下

str1 != str2
str2 == str3
public class CompareObject2
{
     
   public static void main(String[] args)
   {
     
      String str1 = new String("Java");
      String str2 = new String("Java");
      String str3 = str2;
      if(str1.equals(str2))
      {
     
         System.out.println("str1 equals str2");
      }else{
     
         System.out.println("str1 not equals str2");
      }
      if(str2.equals(str3))
      {
     
         System.out.println("str2 equals str3");
      }else{
     
         System.out.println("str2 not equals str3");
      }
   }
}

输出结果如下

str1 equals str2
str2 equals str3
11.构造方法

1)构造方法不能被static和final修饰
2)构造方法不能被继承,子类使用父类的构造方法需要使用super关键字
3)类名() -->这也是一个构造方法

class book
{
     
	String bookName;//数据成员
	String author;
	int price;
	public book()//构造函数
	{
     
		bookName = "小王子";
		author = "eksan";
		price = 999;
	}
	public book(String bookName,String author,int price)//构造函数
	{
     
		this.bookName = bookName;
		this.author = author;
		this.price = price;
	}
	public String show() {
     
		return "书名:" + bookName +
		       "\n作者:" + author + 
		       "\n价格:" + price;
	}
}
public class bookDemo {
     

	public static void main(String[] args){
     
		// TODO Auto-generated method stub

		book b1 = new book();//book()就是一个构造函数,创建了一个book类成员变量b1
		book b2 = new book("回到过去","Eksan",666);//book("回到过去","Eksan",666)就是一个构造函数,创建了一个book类成员变量b2
		
		System.out.println(b1.show());
		System.out.println();
		System.out.println(b2.show());
	}
}
// 结果如下
书名:小王子
作者:eksan
价格:999

书名:回到过去
作者:Eksan
价格:666
12.代码块

可以有多个代码块

1)普通代码块

方法体内用一堆大括号括起来的代码区间。
只能放在方法体内

public class Putong {
     
   public static void main(String[] args){
     
   	// "{}" 括号括起来的就是普通的代码块
   	{
     
   		int x = 10;
   		System.out.println("普通的代码块内,x = " + x);
   	}
   	
   	int x = 100;
   	System.out.println("x = " + x);
   }
}
// 结果如下
普通的代码块内,x = 10
x = 100
2)构造代码块

在类中直接定义的,没有任何修饰符的代码块
构造代码块和构造方法一样,是在对象生成时被调用,但构造代码块调用时间比构造方法早
如果只有一个代码块,10个构造函数,每一个构造函数执行之前先执行构造代码块

class Person
{
     
	private String name;
	private int x;
	//构造代码块
	{
     
		System.out.println("构造代码块执行.....");
		x = 100;
	}
	//构造方法的代码块
	Person()
	{
     
		System.out.println("构造方法执行.......");
		name = "Eksan";
		show();
	}
	//构造方法的代码块
	Person(String name)
	{
     
		System.out.println("构造方法执行........");
		this.name = name;
		show();
	}
	void show() {
     
		System.out.println("Welcome! " + name);
		System.out.println("x = " + x);
	}
}
public class Gouzao {
     

	public static void main(String[] args){
     
		
		Person p1 = new Person();
		System.out.println("..........................");
		Person p2 = new Person("Eksan");
	}
}

//执行结果如下

构造代码块执行.....
构造方法执行.......
Welcome! Eksan
x = 100
..........................
构造代码块执行.....
构造方法执行........
Welcome! Eksan
x = 100
3)静态代码块

使用static关键字加以修饰并用大括号括起来的代码块
最早执行的代码块之一

public class HelloWorld {
     

	//静态代码块
	static
	{
     
		System.out.println("静态代码块执行...........");
	}
	//构造方法
	public HelloWorld() {
     
		System.out.println("构造方法执行............");
	}
	//构造代码块
	{
     
		System.out.println("构造代码块执行...........");
	}
	public static void main(String[] args){
     
		
		System.out.println("main方法开始执行.........");
		System.out.println("创建第1个对象............");
		new HelloWorld();
		System.out.println("创建第2个对象............");
		new HelloWorld();
		System.out.println("创建第3个对象............");
		new HelloWorld();
	}
}
// 执行结果如下

静态代码块执行...........
main方法开始执行.........
创建第1个对象............
构造代码块执行...........
构造方法执行............
创建第2个对象............
构造代码块执行...........
构造方法执行............
创建第3个对象............
构造代码块执行...........
构造方法执行............

你可能感兴趣的:(java)