java学习笔记

  1. 大括号成对写,对其写
  2. 左大括号前要有空格
  3. 代码缩进
  4. 方法和程序块之间要有空行
  5. 并排语句加空格
  6. 运算符两侧加空格
public class Cws {
	public static void main(String[] args) {
		System.out.println("测试");
	}

}

常量与变量

image-20210221221113176

注释

  • 单行注释

    // 单行注释
    
  • 多行注释

    /*
     * 多行注释
     */
    
  • 文档注释

    /**
     * 文档注释
     */
    

关键字

常见的关键字:

image-20210221222537051

image-20210221222606889

image-20210221222632481

image-20210221222656603

常量

代码语句中直接引用的值即为常量(值不会发生变化)

变量

定义方法:数据类型 变量名称 = 初始化值;

int bianLiang = 1;

数据类型

image-20210221223448191

整数型

名称 解释
byte 字节
short 短整型
int 整形
long 长整型

浮点型

名称 解释
float 单精度(值最后必须加f)
double 双精度

字符型

名称 解释
char 单字符(单引号)

布尔型

名称 解释
boolean true,false

类型转换

目标类型 变量名 =(目标类型)要技换的值

int c = (int)(a+b);

标识符

image-20210221224548358

运算符

image-20210221224949089

算术运算符

image-20210221225040332

自增与自减

在变量前,先自增(自减),再进行其它运算

在变量后,先以原值进行其它运算,再自增(自减)

关系运算符

image-20210221225713879

判断两个变量是否相等尽量使用:

boolean cws = a.equals(b);

逻辑运算符

运算符 解释
&& 并且,两个都对即为对
|| 或者,有一个对即为对
非,否定的意思

三元运算符

表达式?表达式:表达式; //类似于if的简化模式,表达式1对执行2,不对执行3

键盘录入(Scanner)

这是一个调试程序的东西,类似于打印到控制台,所以要先说

导包(将这个类所在的包进行导入)

import java.util.Scanner;

创建对象(及引用类并用一个对象接收)

Scanner sc=new Scanner(System.in);

调用方法

int ci=sc.nextInt();

流程语句

If

if(1==1){
	System.out.println(1);
}

if(1==1){
	System.out.println(1);
} else {
	System.out.println(2);
}

if(1==1){
	System.out.println(1);
} else if(2==1) {
	System.out.println(2);
}

Switch

程序判断a是否等于一,如果没有break,那将继续往下执行,如果找到,将忽视其他的case

switch (a) {
case 1:
	System.out.println(1);
	break;
case 2:
	System.out.println(2);
	break;

default:
     System.out.println("!");   
	break;
}

For

for (int i = 0; i < 10; i++) {
	System.out.println(i);
}

While

image-20210222131818653
int i=0;
while (i<10) {
	System.out.println(i);
	i++;
}

Do ... While

先执行一遍然后再判断是否继续循环

int i=0;
do {
	System.out.println(i);
	i++;
} while (i<10);

Break和Continue

Break:结束整个循环语句

Continue:结束本次循环,循环语句将被继续

标号

结束指定循环语句,一般用于循环的嵌套,详细看代码

image-20210222134405538

随机数生成

Random

导包

import java.util.Random;

创建对象

Random ra=new Random();

调用

System.out.println(ra.nextInt(11));		//随机生成0-10的整数

Math.random()

int max=100,min=1;			//随机生成1-100,包括1和100
int ran2 = (int) (Math.random()*(max-min)+min);

方法

方法也叫函数,一般把指定功能放在一个方法中,提高复读型和效率

格式与例子

修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2){
    // 方法体语句
    return 返回值;
}

//===================================================

public static void main(String[] args) {
	System.out.println(cws(1));
}
private static int cws(int a) {
	System.out.println(a);
	return a;
}

方法重载

在同一类中多个相同名称的方法但参数不同,这种情况叫方法重载,与返回值类型无关

一般用于相同功能,但是参数不同

数组

定义方法

定义之后如果没有赋值,那么默认是有初始值的

方法一:

int[] arr = new int[10];			//先定义长度后赋值
for (int i = 0; i < arr.length; i++) {
arr[i]=i;
}

方法二:

int[] arr1 = new int[]{1,2,3,4,5,6,7,8,9,10};	//申明是直接赋值

方法三:

int[] arr1 = {1,2,3,4,5,6,7,8,9,10};		//省略格式

引用方法

数组名[序号]:从0开始

遍历

数组名.length:返回数组的长度

int[] arr1 = {1,2,3,4,5,6,7,8,9,10};
for (int i = 0; i < arr1.length; i++) {
	System.out.println(arr1[i]);
}

内存图解

image-20210222155043192

创建数组是在内存中开辟一片空间,所以直接输出数组只是输出数组在内存中的地址,并不是值

数组=数组1:假如数组发生改变,数组1也会改变,因为数组=数组1只是把数组1在内存中的地址赋值给了数组,并没有将值给数组,所以实际上数组和数组1指的是同一个东西

image-20210222155526415

例子

import java.util.Arrays;
import java.util.Collections;
 
public class Main {
    public static void main(String[] args) {
        Integer[] numbers = { 8, 2, 7, 1, 4, 9, 5};
        int min = (int) Collections.min(Arrays.asList(numbers));
        int max = (int) Collections.max(Arrays.asList(numbers));
        System.out.println("最小值: " + min);
        System.out.println("最大值: " + max);
    }
}

面向对象

面向对象编程即为面向类,因为对象只是类的具体表现

构建方法

方法名与类名相同,没有返回值但可以有参数,创建对象的时候首先运行,如果没有程序将自动生成空的构建方法

public class Lei {
	public Lei() {
		System.out.println("构造方法");
	}
	
	
	public Lei(int a2) {
		System.out.println(a2);
	}
}

public static void main(String[] args) {
    Lei l = new Lei();
    Lei l1 = new Lei(11111);
}

重载

方法名相同,参数不同,返回值不一定相同的叫做重载

static

静态修饰符,在编译的时候先写入到内存中,可以使用类名直接调用

修饰方法时,方法中不能调用非静态变量

静态代码块
static{
    syso("1")
}

final

常量修饰符

封装

将一些功能封装成方法或者类,这样方便后期维护,提高了效率

类与对象

类:属性与行为的结合,抽象概念,一个功能的集合

对象:是该类的具体表现,对该功能的具体使用

属性(成员变量)与行为(成员方法)组成的一个文件叫类

public class Lei {
	int a;
	public int getA() {
		return this.a;
	}
}

对象

对象是类的具体表现,调用一个类需要先创建这个类的对象,调用对象即为调用这个类

创建与引用

类名 方法名 = new 类名();
对象名.变量名
对象名.方法名()
    
Lei l = new Lei();
l.a = 1;
System.out.println(l.getA());

一个对象创建的内存图解:

image-20210222173105292

两个:

image-20210222173203969

标准类

public class BiaoZhui {
	private String name;
	private int agg;
	
	public BiaoZhui() {
	}
	public BiaoZhui(String name, int agg) {
		this.name = name;
		this.agg = agg;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAgg() {
		return agg;
	}
	public void setAgg(int agg) {
		this.agg = agg;
	}
}

Private和This

Private

私有的,关键字,可以提高类的安全性,一般用于类中成员变量

作用:声明私有成员变量,别的类无法访问

private int cws = 1;

This

指针,谁调用它它就只想谁,一般用于直接调用本类中的成员变量

this.成员变量

例子:

public class Lei {
	private int a = 2;
	public void getA() {
		int a = 1;
		System.out.println(a);
		System.out.println(this.a);
	}
}

public class Cws {
	public static void main(String[] args) {
		Lei l = new Lei();
		l.getA();
	}
}

继承

子类继承父类的所有非私有属性与方法

public class 子类 extends 父类 {
}

super

this调用本类,super调用父类

final

最终版,不允许继承

修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}
posted @ 2021-02-23 18:33  陈文生  阅读(21)  评论(0编辑  收藏