目录
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.随机数
可以使用java.util.Random类产生随机数
Random类有了一个名为nextInt()的方法：public int nextInt(int n)
给定一个参数n，nextInt(n)将返回一个大于等于0小于n的随机数，即：0 <= nextInt(n) < n。
连接:rand.nextint()
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)的随机整数
}
}
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个对象............
构造代码块执行...........
构造方法执行............
1050
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
