笔记
1、数组是储存在堆上的对象,可以保存多个同类型变量。
2、Java中的枚举,限制了变量只能是预先设定好的值。
例如,我们为果汁店设计一个程序,它将限制果汁为小杯、中杯、大杯。这就意味着它不允许顾客点除了这三种尺寸外的果汁。
3、this 本类。
4、接口:接口可理解为对象间互相通信的协议。接口在继承中扮演者很重要的角色。接口只定义派生要用到的方法,但是方法的具体实现完全取决于派生类。
5、自动类型转换与强制类型转换:
自动类型转换必须满足转换前的数据类型的位数要低于转换后的。
转换从低级到高级。
低-------------------------------------------------------------------->高
byte,short,char——>int——>long——>float——>double
数据类型转换必须满足如下规则:
①不能对boolean类型进行类型转换。
②不能把对象类型转换成不相关类的对象。
③在把容量大的类型转换为容量小的类型时必须使用强制类型转换。
④转换过程中可能导致溢出或损失精度,例如:
int i = 128;
byte b = (byte) i;
因为byte类型是8位,最大值为127,所以当int强制转换为byte类型时,值128时候就会导致溢出。
浮点数到整数的转换是通过舍弃小数得到,而不是四舍五入,例如:
(int)23.7 == 23;
(int)-45.89f == -45;
强制类型的转换用于转换前的数据类型位数高于转换后的。
例如:int i=123;
byte b = (byte) i;//强制类型转换为byte。
6、java局部变量
非访问修饰符
对类变量和方法的访问可以直接使用classname.viarablename和classname.methodname的方式访问。
abstract class Caravan{
private double price;
private String model;
private String year;
public abstract void goFast();//抽象方法
public abstract void changeColor();
}
抽象方法:
抽象方法是一种没有任何实现的方法,该方法的具体实现由子类提供。
抽象方法不能被声明成final和static。
任何继承抽象类的子类必须实现父类的所有抽象方法,除非该子类也是抽象类。
如果一个类包含若干个抽象方法,那么该类必须声明为抽象类。抽象类可以不包含抽象方法。
抽象方法的声明以分号结尾,例如:public abstract sample();。
public abstract class SuperClass{
abstract void m();
}
calss SubClass extends SuperClass{
//实现抽象方法
void m(){.............}
}
public synchronized void showDetails(){
................
}
public class MyRunnable implements Runnable
{
private volatile boolean active;
public void run(){
active = true;
while(active){ //第一行
//代码
}
}
public void stop(){
active = false; //第二行
}
}
通常情况下,在一个线程调用run()方法(在Runnable开启的线程),在另一个线程调用stop()方法。如果第一行中缓冲区的active值被使用,那么在第二行的active值为false时循环不会停止。
但是以上代码中我们使用了volatile修饰active,所以该循环会停止。
9、Java运算符
短路逻辑运算符
当使用与逻辑运算符时,在两个操作数都为true时,结果才为true,但是当得到第一个操作为false时,其结果就必定是false,这时候就不再判断第二个操作了。
public class LuoJi{
public static void main(String[] args){
int a=5;
boolean b = (a<4)&&(a++<10)
System.out.println("使用短路逻辑运算符的结果为"+b);
System.out.println("a的结果为"+a);
}
}
运行结果为:
使用短路逻辑运算符的结果为false
a的结果为5
解析:该程序使用到了短路逻辑运算符(&&),首先判断a<4的结果为false,则b的结果必定是false,所以不再执行第二个操作a++<10的判断,所以a的值为5。
条件运算符(?:)
条件运算符也被称为三元运算符。该运算符有3个操作数,并且需要判断布尔表达式的值。该运算符主要是决定哪个值应该赋值给变量。
variable x = (expression)? value if true : value if false;
int a,b;
a = 10;
//如果a等于1成立,则设置b为20,否则为30
b = (a == 1) ? 20 : 30;
instanceof运算符
该运算符用于操作对象实例,检查该对象是否是一个特定类型(类类型或接口类型)。格式:(Object reference variable)instanceof(class/interface type)
例:
String name = "James";
boolean result = name instanceof String; //由于name是String类型,所以返回真。
如果被比较的对象兼容于右侧类型,该运算符仍然返回true。
class Vehicle{}
public class Car extends Vehicle{
public static void main(String[] args){
Vehicle a = new Car();
boolean result = a instanceof Car;
System.out.println(result);
}
}
以上实例运行结果为:true。
10、Switch case语句
如果case语句块中没有break语句时,匹配成功后,从当前case开始,后续所有case的值都会输出。例:
int i=1;
switch(i){
case 0;
System.out.println("0");
case 1;
System.out.println("1");
case 2;
System.out.println("2");
default:
System.out.println("default");
}
运行结果:
1
2
default
如果当前匹配成功的case语句块没有break语句,则从当前case开始,后续所有case的值都会输出,如果后续的case语句块有break语句则会跳出判断
int i=1;
switch(i){
case 0;
System.out.println("0");
case 1;
System.out.println("1");
case 2;
System.out.println("2");
break;
default:
System.out.println("default");
}
运行结果:
1
2
11、java循环结构
Java增强for循环java增强for循环主要用于数组,格式如下:
for(声明语句:表达式){
//代码句子
}
声明语句:声明新的局部变量,该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块,其值与此时数组元素的值相等。
表达式:表达式是数组名,或者是返回值为数组的方法。
public class Test {
public static void main(String args[]){
int [] numbers = {10, 20, 30, 40, 50};
for(int x : numbers ){
System.out.print( x );
System.out.print(",");
}
System.out.print("\n");
String [] names ={"James", "Larry", "Tom", "Lacy"};
for( String name : names ) {
System.out.print( name );
System.out.print(",");
}
}
}
以上实例编译运行结果如下:
10,20,30,40,50,
James,Larry,Tom,Lacy,
break关键字
break主要用在循环语句或者switch语句中,用来跳出整个语句块。
break跳出最里层的循环,并且继续执行该循环下面的语句。
实例:
public class Test {
public static void main(String args[]) {
int [] numbers = {10, 20, 30, 40, 50};
for(int x : numbers ) {
// x 等于 30 时跳出循环
if( x == 30 ) {
break;
}
System.out.print( x );
System.out.print("\n");
}
}
}
以上实例编译运行如下:
10
20
continue关键字
continue适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。
在for循环中,continue语句使程序立即跳转到更新语句。
在while或者do…while循环中,程序立即跳转到布尔表达式的判断语句。
实例:
public class Test {
public static void main(String args[]) {
int [] numbers = {10, 20, 30, 40, 50};
for(int x : numbers ) {
if( x == 30 ) {
continue;
}
System.out.print( x );
System.out.print("\n");
}
}
}
以上实例编译运行结果如下:
10
20
40
50
12、Java数组
声明数组变量
dataType[] arrayRefVar; //首选的方法
dataType arrayRefVar[]; //效果相同,但不是首选方法
注意:建议使用dataType[] arrayRefVar的声明风格声明数组变量。
//实例
double[] myList; //首选的方法
double myList[]; //效果相同,但不是首选方法
创建数组
Java语言使用new操作符来创建数组,语法如下:
arrayRefVar = new dataType[];
上面的语法语句做了两件事:
数组变量的声明,和创建数组可以用一条语句完成,如下所示:
dataType[] arrayRefVar = new dataType[arraySize];
另外,你还可以使用如下的方式创建数组。
dataType[] arrayRefVar = {value0,value1,...,valuen};
数组的元素是通过索引访问的。数组索引从0开始,所以索引值从0到arrayRefVar.length-1。
For-Each循环
For-Each循环也叫做加强型循环,它能在不使用下标的情况下遍历数组。
格式如下:
for(type element:array){
System.out.println(element);
}
实例:
public class TestArray {
public static void main(String[] args) {
double[] myList = {1.9, 2.9, 3.4, 3.5};
// 打印所有数组元素
for (double element: myList) {
System.out.println(element);
}
}
}
以上实例编译运行结果如下:
1.9
2.9
3.4
3.5
数组作为函数的参数
数组可以作为参数传递给方法。
例如,下面的例子就是一个打印int数组中元素的方法:
public static void printArray(int[] array) {
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
}
下面例子调用 printArray 方法打印出 3,1,2,6,4 和 2:
printArray(new int[]{3, 1, 2, 6, 4, 2});
数组作为函数的返回值:
public static int[] reverse(int[] list){
int[] result = new int[list.length];
for(int i = 0,j = result.length - 1; i < list.length; i++, j--){
result[j] = list[i];
}
return result;
}
以上实例中result数组作为函数的返回值。
Arrays类
java.util.Arrays类能方便地操作数组,它提供的所有方法都是静态的。
具有以下功能:
13、Java方法
在前几章中我们经常使用到System.out.println(),那么它是什么呢?
这句话的用法是调用系统类System中的标准输出对象out中的方法println()。
那么什么是方法呢?
Java方法是语句的集合,它们在一起执行一个功能。
方法的优点
方法的命名规则
test_
,例如testPop_emptyStack
。方法的定义
一般情况下,定义一个方法包含以下语法:
修饰符 返回值类型 方法名(参数类型 参数名){
...
方法体
...
return 返回值;
}
方法包含一个方法头和一个方法体。下面是一个方法的所有部分。
如:public static int age(int birthday){.....}
参数可以有多个:static float interest(float principle, int year){..}
方法调用
Java支持两种调用方法的方式,根据方法是否返回值来选择。
当程序调用一个方法时,程序的控制权交给了被调用的方法。当被调用方法的返回语句执行或者到达方法体闭括号时候交还控制权给程序。
当方法返回一个值的时候,方法调用通常被当做一个值。例如:
int larger = max(30 , 40);
如果方法返回值是void,方法调用一定是一条语句。例如,方法println返回void。下面的调用是条语句。
System.out.println("欢迎访问牛客教程!");
通过值传递参数
调用一个方法有时候需要提供参数,必须按照参数列表指定的顺序提供。
示例:
public class TestPassByValue {
public static void main(String[] args) {
int num1 = 1;
int num2 = 2;
System.out.println("交换前 num1 的值为:" +
num1 + " ,num2 的值为:" + num2);
// 调用swap方法
swap(num1, num2);
System.out.println("交换后 num1 的值为:" +
num1 + " ,num2 的值为:" + num2);
}
/** 交换两个变量的方法 */
public static void swap(int n1, int n2) {
System.out.println("\t进入 swap 方法");
System.out.println("\t\t交换前 n1 的值为:" + n1
+ ",n2 的值:" + n2);
// 交换 n1 与 n2的值
int temp = n1;
n1 = n2;
n2 = temp;
System.out.println("\t\t交换后 n1 的值为 " + n1
+ ",n2 的值:" + n2);
}
}
以上实例编译运行结果如下:
交换前 num1 的值为:1 ,num2 的值为:2
进入 swap 方法
交换前 n1 的值为:1,n2 的值:2
交换后 n1 的值为 2,n2 的值:1
交换后 num1 的值为:1 ,num2 的值为:2
可以发现,传递两个参数的swap方法,方法被调用后,实参的值并没有变。
方法的重载
上面使用的max方法仅仅适用于int型数据。但如果你想得到两个浮点型数据的最大值呢?解决方法是创建另一个有相同名字但参数不同的办法,如下面代码所示:
public static double max(double num1, double num2) {
if (num1 > num2)
return num1;
else
return num2;
}
如果你调用max方法时传递的是int型参数,则 int型参数的max方法就会被调用;
如果传递的是double型参数,则double类型的max方法体会被调用,这叫做方法重载;
就是说一个类的两个方法拥有相同的名字,但是有不同的参数列表。
Java编译器根据方法签名判断哪个方法应该被调用。
方法重载可以让程序更清晰易读。执行密切相关任务的方法应该使用相同的名字。
重载的方法必须拥有不同的参数列表。你不能仅仅依据修饰符或者返回类型的不同来重载方法。
变量作用域
变量的范围是程序中该变量可以被引用的部分。
方法内定义的变量被称为局部变量。
局部变量的作用范围从声明开始,直到包含它的块结束。
局部变量必须声明才可以使用。
方法的参数范围涵盖整个方法。参数实际上是一个局部变量。
for循环的初始化部分声明的变量,其作用范围在整个循环。
但循环体内声明的变量其适用范围是从它声明到循环结束。它包含如下所示的变量声明:
你可以在一个方法里,不同的非嵌套块中多次声明一个具有相同的名称局部变量,但你不能在嵌套块内两次声明局部变量。
命令行参数的使用
有时候你希望运行一个程序时候再传递给它消息。这要靠传递命令行参数给main()函数实现。
命令行参数是在执行程序时候紧跟在程序名字后面的信息。
实例:
下面的程序打印所有的命令行参数:
public class CommandLine {
public static void main(String args[]){
for(int i=0; i<args.length; i++){
System.out.println("args[" + i + "]: " + args[i]);
}
}
}
如下所示,运行这个程序:
$ javac CommandLine.java
$ java CommandLine this is a command line 200 -100
args[0]: this
args[1]: is
args[2]: a
args[3]: command
args[4]: line
args[5]: 200
args[6]: -100
构造方法
当一个对象被创建的时候,构造方法用来初始化该对象。构造方法和它所在类的名字相同,但构造方法没有返回值。
通常会使用构造方法给一个类的实例变量赋初值,或者执行其它必要的步骤来创建一个完整的对象。
不管你是否自定义构造方法,所有的类都有构造方法,因为Java自动提供了一个默认构造方法,默认构造方法的访问修改符和类的访问修改符相同(类为public,构造函数也为public。类为private,构造函数也为private。)
一旦你定义了自己的构造方法,默认构造方法就会失效。
实例
下面是一个使用构造方法的例子:
//一个简单的构造函数
class MyClass{
int x;
//以下是构造函数
MyClass(){
x = 10;
}
}
你可以像下面这样调用构造方法来初始化一个对象:
public class ConsDemo{
public static void main(String args[]){
MyClass t1 = new MyClass();
MyClass t2 = new MyClass();
System.out.println(t1.x + " " + t2.x)
}
}
大多时候需要一个有参数的构造方法。
实例
下面是一个使用构造方法的例子:
//一个简单的构造函数
class MyClass{
int x;
//以下是构造函数
MyClass(int i){
x=i;
}
}
你可以像下面这样调用构造方法来初始化一个对象:
public class ConsDemo{
public static void main(String args[]){
MyClass t1 = new MyClass(10);
MyClass t2 = new MyClass(20);
System.out.println(t1.x + " " + t2.x);
}
}
运行结果如下:
10 20
可变参数
Java支持传递同类型的可变参数给一个方法。
方法的可变参数的声明:typeName...parameterName
在方法声明中,在指定参数类型后加一个省略号(…)。
一个方法中只能指定一个可变参数,它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。
实例
public class VarargsDemo {
public static void main(String args[]) {
// 调用可变参数的方法
printMax(34, 3, 3, 2, 56.5);
printMax(new double[]{1, 2, 3});
}
public static void printMax( double... numbers) {
if (numbers.length == 0) {
System.out.println("No argument passed");
return;
}
double result = numbers[0];
for (int i = 1; i < numbers.length; i++){
if (numbers[i] > result) {
result = numbers[i];
}
}
System.out.println("The max value is " + result);
}
}
运行结果如下:
The max value is 56.5
The max value is 3.0
finalize()方法
Java允许定义这样的方法,它在对象被垃圾收集器析构(回收)前调用,这个方法叫做finalize(),它用来清除回收对象。
例如,你可以使用finalize()来确保一个对象打开的文件被关闭了。
在finalize()方法里,你必须指定在对象销毁时候要执行的操作。
finalize()一般格式是:
protected void finalize(){
//在这里终结代码
}
关键字protected是一个限定符,它确保finalize()方法不会被类以外的代码调用。
当然,Java的内存回收可以由JVM来自动完成。如果你手动使用,则可以使用上面的办法。
实例
public class FinalizationDemo {
public static void main(String[] args) {
}
}
class Cake extends Object{
private int id;
public Cake(int id){
this.id = id;
System.out.println("Cake Object " + id +"is created");
}
protected void finalize() throws java.lang.Throwable{
super.finalize();
System.out.println("Cake Object " + id + "is disposed");
}
}
运行以上代码,输出结果如下:
$ javac FinalizationDemo.java
$ java FinalizationDemo
Cake Object 1is created
Cake Object 2is created
Cake Object 3is created
Cake Object 3is disposed
Cake Object 2is disposed
14、Java Scanner类
Scanner类用来获取用户的输入,下面是创建Scanner对象的基本语法:
Scanner s = new Scanner(System.in);
接下来我们演示一个最简单的数据输入,并通过Scanner类的next()与nextLine()方法获取输入的字符串,在读取前我们一般需要使用hasNext与hasNextLine判断是否还有输入的数据:
使用next方法
import java.util.Scanner;
public class ScannerDemo{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
//从键盘接收数据
//next方式接收字符串
System.out.println("next方式接收:");
//判断是否还有输入
if(scan.hasNext()){
String str1 = scan.next();
System.out.println("输入的数据为:" + str1);
}
scan.close();
}
}
执行以上程序输出结果为:
$ javac ScannerDemo.java
$ java ScannerDemo
next方式接收:
nowcoder com
输入的数据为:nowcoder
可以看到com字符串并未输出,接下来我们看nextLine。
使用nextLine方法:
import java.util.Scanner;
public class ScannerDemo{
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
//从键盘接收数据
//nextLine方式接收字符串
System.out.println("nextLine方式接收:");
//判断是否还有输入
if(scan.hasNextLine()){
String str2 = scan.nextLine();
System.out.println("输入的数据为:" + str2);
}
scan.close();
}
}
执行以上输出结果为:
$ javac ScannerDemo.java
$ java ScannerDemo
nextLine方式接收:
nowcoder com
输入的数据为:nowcoder com
可以看到com字符串输出。
next()与nextLine()区别
next();
nextLine();
如果要输入int或float类型的数据,在Scanner类中也有支持,但是在输入之前最好先使用hasNextXxx()方法进行验证,再使用nextXxx()来读取。
import java.util.Scanner;
public class ScannerDemo {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
// 从键盘接收数据
int i = 0;
float f = 0.0f;
System.out.print("输入整数:");
if (scan.hasNextInt()) {
// 判断输入的是否是整数
i = scan.nextInt();
// 接收整数
System.out.println("整数数据:" + i);
} else {
// 输入错误的信息
System.out.println("输入的不是整数!");
}
System.out.print("输入小数:");
if (scan.hasNextFloat()) {
// 判断输入的是否是小数
f = scan.nextFloat();
// 接收小数
System.out.println("小数数据:" + f);
} else {
// 输入错误的信息
System.out.println("输入的不是小数!");
}
scan.close();
}
}
执行以上程序输出结果为:
$ javac ScannerDemo.java
$ java ScannerDemo
输入整数:12
整数数据:12
输入小数:1.2
小数数据:1.2
以下实例我们可以输入多个数字,并求其总和与平均数,每输入一个数字用回车确认,通过输入非数字来结束输入并输出执行结果:
import java.util.Scanner;
class ScannerDemo {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
double sum = 0;
int m = 0;
while(scan.hasNextDouble()){
double x = scan.nextDouble();
m = m + 1;
sum = sum + x;
}
System.out.println(m + "个数的和为" + sum);
System.out.println(m + "个数的平均值是" + (sum / m));
scan.close();
}
}
执行以上程序输出结果为:
$ javac ScannerDemo.java
$ java ScannerDemo
12
23
15
21.4
end
4个数的和为71.4
4个数的平均值是17.85
我们对Markdown编辑器进行了一些功能拓展与语法支持,除了标准的Markdown编辑器功能,我们增加了如下几点新功能,帮助你用它写博客:
撤销:Ctrl/Command + Z
重做:Ctrl/Command + Y
加粗:Ctrl/Command + B
斜体:Ctrl/Command + I
标题:Ctrl/Command + Shift + H
无序列表:Ctrl/Command + Shift + U
有序列表:Ctrl/Command + Shift + O
检查列表:Ctrl/Command + Shift + C
插入代码:Ctrl/Command + Shift + K
插入链接:Ctrl/Command + Shift + L
插入图片:Ctrl/Command + Shift + G
查找:Ctrl/Command + F
替换:Ctrl/Command + G
直接输入1次#,并按下space后,将生成1级标题。
输入2次#,并按下space后,将生成2级标题。
以此类推,我们支持6级标题。有助于使用TOC
语法后生成一个完美的目录。
强调文本 强调文本
加粗文本 加粗文本
标记文本
删除文本
引用文本
H2O is是液体。
210 运算结果是 1024.
链接: link.
图片:
带尺寸的图片:
居中的图片:
居中并且带尺寸的图片:
当然,我们为了让用户更加便捷,我们增加了图片拖拽功能。
去博客设置页面,选择一款你喜欢的代码片高亮样式,下面展示同样高亮的 代码片
.
// An highlighted block
var foo = 'bar';
一个简单的表格是这么创建的:
项目 | Value |
---|---|
电脑 | $1600 |
手机 | $12 |
导管 | $1 |
使用:---------:
居中
使用:----------
居左
使用----------:
居右
第一列 | 第二列 | 第三列 |
---|---|---|
第一列文本居中 | 第二列文本居右 | 第三列文本居左 |
SmartyPants将ASCII标点字符转换为“智能”印刷标点HTML实体。例如:
TYPE | ASCII | HTML |
---|---|---|
Single backticks | 'Isn't this fun?' |
‘Isn’t this fun?’ |
Quotes | "Isn't this fun?" |
“Isn’t this fun?” |
Dashes | -- is en-dash, --- is em-dash |
– is en-dash, — is em-dash |
一个具有注脚的文本。2
Markdown将文本转换为 HTML。
您可以使用渲染LaTeX数学表达式 KaTeX:
Gamma公式展示 Γ ( n ) = ( n − 1 ) ! ∀ n ∈ N \Gamma(n) = (n-1)!\quad\forall n\in\mathbb N Γ(n)=(n−1)!∀n∈N 是通过欧拉积分
Γ ( z ) = ∫ 0 ∞ t z − 1 e − t d t . \Gamma(z) = \int_0^\infty t^{z-1}e^{-t}dt\,. Γ(z)=∫0∞tz−1e−tdt.
你可以找到更多关于的信息 LaTeX 数学表达式here.
可以使用UML图表进行渲染。 Mermaid. 例如下面产生的一个序列图:
这将产生一个流程图。:
我们依旧会支持flowchart的流程图:
如果你想尝试使用此编辑器, 你可以在此篇文章任意编辑。当你完成了一篇文章的写作, 在上方工具栏找到 文章导出 ,生成一个.md文件或者.html文件进行本地保存。
如果你想加载一篇你写过的.md文件,在上方工具栏可以选择导入功能进行对应扩展名的文件导入,
继续你的创作。
mermaid语法说明 ↩︎
注脚的解释 ↩︎