java 学习笔记
第一、二、三章:略
4:Java语言的编写、编译与运行:
4.1:Java程序的编写:
- 在java中,如果源代码只有一个类,那么类的名称要与文件名一致,否则会出错。
- Java大小写敏感,请注意!
4.2:Java文件的命名规则:
- 只要是Java程序就必须放在一个类中,例如
[public] class 类名称{}
首字母必须大写,一个Java文件只能有一个public类 - 只能有一个public class类,但是class类可以有很多
4.3:主方法:
- 任何程序都是从主方法中开始执行,定义如下:
public static void main(String args[]){ } - 输出语句:System.out.println() ;。ln是指输出时会换一行,如果没有ln就是直接输出而没有换行。
5:Eclipse:略
6:Java语言基础:
6.1:注释标记
与之前学过的差不多,略
6.2:基本数据类型
注意:
3. 定义float类型的数据,要在小数之后加上f。定义long类型的要在整数后面加上L
4. 在Java中数字并不能代表true和false,布尔值只能是True和False(大小写注意!)
6.3:关键字与标识符:
标识符由字母、数字、下划线、$组成
6.4:运算符:
- 不必死记硬背优先级,善于用小括号
- 三目运算符:
a>b?a:b意思是若a>b为真,则返回a,假的话返回b。 - 逻辑运算符&与&&:
&:两个都要判断
&&:短路,前面的不满足后面的就不判断了。 - 逻辑运算符|与||:
|是两个都判断,||是前面的满足了的话后面的就不需要看了。 - 位运算符&与|:
&是两个都是1才能是1,|是有1则1. - 移位操作:<<与>>
7:流程控制:
7.1:选择语句:
- if语句:
public class IfElseSelect{
public static void main(String args[]) {
} }
int age = 300;
if (age >= 0 && age <= 12) {
System.out.println("现在是少年期!");
} else if (age > 12 && age <= 18) {
System.out.println("现在是青少年期!");
} else if (age > 18 && age <= 40) {
System.out.println("青年期");
} else if (age > 40 && age <= 55) {
System.out.println("中年期"); } else if (age > 200) {
System.out.println("黑山老妖!"); }
- switch语句:
switch(参数) {
case 常量表达式 1: break; case 常量表达式 2: break; ...
default: break;
}
注意:
switch接受的参数类型有10种,分别是基本类型的byte,short,int,char,以及引用类型的String(只有JavaSE7及以上版本接受String类型参数), enum和 byte,short,int,char 的封装类 Byte,Short,Integer,Character
· case 后紧跟常量表达式,不能是变量。
· default语句可有可无,如果没有case语句匹配,default语句会被执行。
· case语句和default语句后的代码可不加花括号。
· 如果某个case语句匹配,那么case后面的语句块会被执行,且如果后面没有break 关键字,会继续执行后面的 case 语句代码和 default,直到遇见 break 或者右花括号。
7.2:循环语句:
- while语句:
先判断后执行 - do…while语句:
限制性后判断 - for语句:
最常用的语句
注意这个用法:foreach语句,在遍历数组、集合方面,foreach为开发人员提供了极大的方便,for- each 的语句格式:
for(元素类型 t 元素变量 x : 遍历对象 obj){ 引用了x的Java语句;
}
例如:
public class ForeachExample{
public static void main(String[] args) {
String[] books = { "Java", "c", "c++", "c#", "asp" };
for (String book : books) {
System.out.println(book); }
}
}
}
输出结果:
Java
c
c++
c#
asp
7.3:跳转语句:
- break :跳出当前循环;但是如果是嵌套循环,则只能跳出当前的这一层循环,只有逐层 break 才能跳出所有循环。
- continue:终止当前循环,但是不跳出循环(在循环中continue后面的语句是不会执 行了),继续往下根据循环条件执行循环。
- return语句可以终止成员方法的执行并返回至调用这个成员方法的位置。如果这个成 员方法需要返回值,将通过 return 带出。
格式一:return;(只能用于返回类型为 void 的成员方法) 格式二:return 表达式;
- 注意break和continue的区别:
break:
public class BreakExampleInner{
public static void main(String args[]) {
for (int i = 0; i < 3; i++) { System.out.print("Pass " + i + ":"); for (int j = 0; j < 100; j++) {
if (j == 10)
break; // terminate loop if j is 10
System.out.print(j + " "); }
System.out.println(); }
System.out.println("Loops complete."); }
}
结果:
Pass 0:0 1 2 3 4 5 6 7 8 9
Pass 1:0 1 2 3 4 5 6 7 8 9
Pass 2:0 1 2 3 4 5 6 7 8 9
Loops complete.
continue:
public class continueExample{
public static void main(String[] args) {
for (int i = 0; i < 5; i++) { if (i == 3)
continue; System.out.println("i=" + i);
}
System.out.println("Loop complete.");
} }
结果:
i=0
i=1
i=2
i=4
Loop complete.
8:方法:
8.1:方法(函数)的定义:
在程序中,如果某一段代码需要被重复调用的时候,就可以通过方法来完成,方法的定义格式如下:(在涉及面向对象内容之前,我们采用 static 类型的方法,只有 static 类型 的方法,主函数中才能调用,在构建对象以后,可以采用“对象.方法”的形式)。
public static 返回值类型 方法名称(参数类型 参数名称,.....){
[return 返回值] ;
}
- 无返回值的定义。得用void
public class MethodDemo01 {
public static void main(String args[]) {
fun(); }
public static void fun() {
System.out.println("*************************");
System.out.println("* JAVA 一起学! *");
System.out.println("*************************");
} }
- 有返回值的定义。必须要在返回值类型上写清楚具体的数据类型:
public class MethodDemo02 {
public static void main(String args[]) { System.out.println(add(10, 20));
}
public static int add(int x, int y) { // 定义两个数字相加
return x + y;
}
}
8.2:方法的重载
方法重载是指在一个类中定义多个同名的方法,但要求每个方法具有不同的参数的类型或参数的个数。
例如:
public class MethodDemo04 {
public static void main(String args[]) { System.out.println(add(10, 20)); System.out.println(add(10.0f, 20.3f)); System.out.println(add(10, 20, 30));
}
public static int add(int x, int y) { // 定义两个整数相加
return x + y;
}
public static float add(float x, float y) { // 定义浮点数相加 return x + y;
return x + y;
}
public static int add(int x, int y, int z) { // 定义三个数字相加
return x + y + z;
}
}
8.3:递归
略
9:数组
数组与之前学的都差不多
注意:
- Java自己提供了许多的方法,Arrays类是一个非常有用数组工具类,里面有很多工具方法,检索、填充、排序、比 较、toString()等
- 数组的两种格式化定义,以及数组的动态静态初始化
10:字符串
Java 中的字符串需要使用 String 类型(实际上是 String 类)进行定义。String 类 的操作中依然可以使用“+”或“+=”进行字符串的连接,各个数据类型的数据只要是碰到 了 String 类的内容,则都统一向 String 进行转换,所以 String 类非常重要。
10.1:string的对象实例化
- 直接赋值:
public class StringDemo01 {
public static void main(String args[]) {
} }
String str = "Hello"; // 定义一个字符串 str += " World"; // 字符串连接 System.out.println(str);
- 构造方法赋值:
public class StringDemo02 {
public static void main(String args[]) {
} }
String str = new String("Hello"); // 定义一个字符串 str += " World"; // 字符串连接 System.out.println(str);
一般,在开发中绝对不能使用关键字 new 实例String类。
10.2:string是不可变类
在 Java 中,String 类是不可变的。那么到底什么是不可变的对象呢?
可以这样认为:如果一个对象,在它创建完成之后,不能再改变它的状态,那么这个对 象就是不可变的。不能改变状态的意思是,不能改变对象内的成员变量,包括基本数据类型 的值不能改变,引用类型的变量不能指向其他的对象,引用类型指向的对象的状态也不能改变。
首先创建一个String对象s,然后让s的值为“ABCabc”,然后又让s的值为“123456”,从打印结果可以看出,s 的值确实改变了。那么怎么还说 String 对象是不可变的呢? · 其实这里存在一个误区:s只是一个String对象的引用,并不是对象本身。对象在内存中是一块内存区,成员变量越多,这块内存区占的空间越大。引用只是一个 4字节的数据,里面存放了它所指向的对象的地址,通过这个地址可以访问对象。
也就是说,s 只是一个引用,它指向了一个具体的对象,当 s=“123456”; 这句代 码执行过之后,又创建了一个新的对象“123456”, 而引用 s 重新指向了这个新的 对象,原来的对象“ABCabc”还在内存中存在,并没有改变。内存结构如下图所示:
10.3:字符串的比较
- “==”
两个数字可以直接用双等号来比较,string一样可以
例如:
public class StringDemo06 {
public static void main(String args[]) {
String str1 = "hello";
String str2 = new String("hello");
String str3 = str2;
System.out.println("str1 == str2 --> " + (str1 == str2));
System.out.println("str1 == str3 --> " + (str1 == str3));
System.out.println("str2 == str3 --> " + (str2 == str3));
} }
结果:
str1 == str2 --> false
str1 == str3 --> false
str2 == str3 --> true
所以“==”用在数值上表示判断是否相等,如果是用在了对象上,则表示的是判断两个 对象的地址是否相等。
所以,比较字符串只能靠equals方法,例如:
public class StringDemo06 {
public static void main(String args[]) {
String str1 = "hello";
String str2 = new String("hello");
String str3 = str2;
System.out.println("str1 == str2 --> " + (str1.equals(str2)));
System.out.println("str1 == str3 --> " + (str1.equals(str3)));
System.out.println("str2 == str3 --> " + (str2.equals(str3)));
} }
可得出结论:
· ==:用于数值比较,比较的是两个字符串的地址值
· equals():用于内容的比较,比较两个字符串的内容是否相等
10.4:string匿名对象
匿名对象,是指没有名字的对象。即没有栈区的引用,只在堆区存在的对象。 在程序中使用“"”括起来的内容就属于字符串,那么对于一个普通的字符串来讲,一个字 符串就是 String 类的匿名对象,可以直接使用,例如:
public class StringDemo08 {
public static void main(String args[]) { System.out.println("hello".equals("hello")); // true
} }
11:类和对象
11.1:面向对象与面向过程的对比
- 因为 Java、C++等语言都支持类和对象,所以使用这些语言编写程序也被称为面向对象编程,这些语言也被称为面向对象的编程语言。C 语言因为不支持类和对象的概念,被称为面向过程的编程语言。
- 在 Java 中,可以将完成某个功能的代码块定义为方法,将具有相似功能的方法定 义在一个类中,也就是定义在一个源文件中(因为一个源文件只能包含一个公共的类), 多个源文件可以位于一个文件夹,这个文件夹有特定的称呼,叫做包。
11.2:类和对象的概念与定义
Java中的类相当于是C语言结构题的升级版,C语言中的结构体可以直接定义变量,变量的数据类型可以不一样,可以通过结构体来定义结构体变量,每个变量拥有相同性质。而在Java中,类不仅可以包含变量,还可以包含函数(方法)。如下:
pubic class Student {
// 通过class关键字类定义类 // 类包含的变量
String name;
int age;
float score;
// 类包含的函数
void say() {
System.out.println(name + "的年龄是 " + age + ",成绩是 " + score);
}
}
public class StudentTest{
public static void main(String[] args) {
Student stu1 = new Student();
// 必须使用new关键字 stu1.name = "小明";
stu1.age = 15;
stu1.score = 92.5f;
stu1.say();
} }
注意,Java与C语言不一样的事,C语言在结构体定义时就可以为变量分配内存空间,而Java不能,必须用new关键字来完成内存空间的分配。
可以将类比喻成图纸,对象比喻成零件,图纸说明了零件的参数及其承担的任务;
一张图纸可以生产出具有相同性质的零件,不同图纸可以生产不同类型的零件。
在Java中,使用new关键字,就可以通过类来创建对象,即将图纸生产成零件,这个过程叫做类的实例化,因此也称对象是类的一个实例。
注意:类只是一张图纸,起到说明的作用,不占用内存空间;对象才是具体的零件,要有地方来存放,才会占用内存空间。(这里顿悟)
类所包含的变量和函数都有特定的称呼,变量被称为属性(通常也称成员变量),函数被称为方法,属性和方法统称为类的成员。
- 类的定义:
在Java中用class来定义类变量,由属性与方法组成 - 对象的定义:
在Java中类定义完之后并不能直接使用,要用new关键字来进行对象操作:
类名称 对象名称 = new 类名称() ;
一旦有了对象之后就能用 对象.属性、对象.方法 来调用属性或者方法了 - 匿名对象,由于匿名对象没有名称,所有事用完一次之后就会被回收
- 命名规则:
· 定义类名称的时候,每个单词的首字母大写:HelloInfo
· 定义方法名称的时候,第一个单词的首字母小写,之后每个单词的首字母大写:
printInfo()
· 定义属性的时候,第一个单词的首字母小写,之后每个单词的首字母大写:
empName
· 定义常量的时候,所有的单词字母都要大写:INFO
· 定义包名称的时候,所有的单词的字母都要小写:org.demo
11.3:封装性
- Java规定类中的每一个属性都必须进行封装
public class Person { // 定义类
private String name; // 表示一个人的姓名
private int age; // 表示一个人的年龄
public void tell() { // 表示一个功能,说话
System.out.println("姓名:" + name + ",年龄:" + age); }
}
封装后就不能直接访问类内的属性了,那么怎么去设定和输出属性呢,我们用setter和getter来设置和取得属性
· setter:public void setName(String n){} -> 设置的时候可以进行检查
· getter:public String getName(){} -> 取得时候只是简单的返回
public class Person { // 定义类
private String name; // 表示一个人的姓名
private int age; // 表示一个人的年龄
public void setName(String n) { // 设置姓名
name = n;
}
public void setAge(int a) { // 设置年龄
if (a >= 0 && a <= 150) { // 合法年龄
age = a; }
}
public String getName() { // 取得姓名
return name; }
public int getAge() { // 取得年龄
return age;
}
public void tell() { // 表示一个功能,说话
System.out.println("姓名:" + name + ",年龄:" + age); }
}
测试类:
public class EncDemo02 {
public static void main(String args[]) {
Person per = new Person();
per.setName("张三");
per.setAge(30);
per.tell();
}
}
这种写法变成了 Java 中的一个标准:只要是属性就必须进行封装,封装之后的属性必须通过 setter 和 getter 设置和取得。