• java教程

    Java

    简单输出

    简单运行HelloWorld.java

    编译：javac 源文件名.java

    /*
这是main方法
main是程序的入口方法
所有代码的执行都是从main方法开始的
*/
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("HelloWorld");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    执行后多个HelloWorld.class

    运行： java HelloWorld

    public class 类名

    在类定义后加上一对大括号

    {}

    在大括号中间添加一个主(main)方法/函数

    public static void main(String [] args){ }

    在主方法的大括号中间添加一行输出语句

    System.out.println(“HelloWorld”);

    数字类型

    整型

    byte，short，int，long

    浮点型

    float，double

    字符型

    char

    布尔型

    booleam

    定义变量

    变量的定义格式：

    ​ 数据类型 变量名 = 初始化值;

    基本数据类型：

    ​ byte,short,int,long,float,double,char,boolean

    public class VariableDemo {
    public static void main(String[] args) {
        //定义byte类型的变量
        byte b = 10;
        System.out.println(10);
        System.out.println(b);
        //定义short类型的变量
        short s = 100;
        System.out.println(s);
        //定义int类型的变量
        int i = 10000;
        System.out.println(i);
        //定义long类型的变量
        long l = 1000000000000000L;
        System.out.println(l);
        //定义float类型的变量
        float f = 12.34F;
        System.out.println(f);
        //定义double类型的变量
        double d = 12.34;
        System.out.println(d);
        //定义char类型的变量
        char c = 'a';
        System.out.println(c);
        //定义boolean类型的变量
        boolean bb = false;
        System.out.println(bb);
        int aa=10,bb=20,cc=30;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30

    开发工具

    Eclipse

    下载和安装、下载 http://eclipse.org/

    定义变量运算符

    * +,-,*,/,%,++,–

    %：判断两个数据是否整除。

    int b = 6;
int c = 7;
System.out.println(b+c);

    • 1
    • 2
    • 3

    赋值运算符

    扩展的赋值运算符：+=,-=,*=,/=,%=

    +=: a+=20;相当于a = (a的数据类型)(a + 20);

    a += 10;// 相当于a = a + 10
System.***\**out\**\***.println("a:" + a);

    • 1
    • 2

    关系运算符

    ==,!=,>,>=,<,<=

    逻辑运算符

    &,|,^,!

    &&,||

    &逻辑与:有false则false。

    |逻辑或:有true则true。

    ^逻辑异或:相同为false，不同为true。

    !逻辑非:非false则true，非true则false。

    三元运算符

    (关系表达式)?表达式1：表达式2；

    如果条件为true，运算后的结果是表达式1；

    如果条件为false，运算后的结果是表达式2；

    int x=3,y=4,z;
z = (x>y)?x:y;//z变量存储的就是两个数的大数

    • 1
    • 2

    键盘录入

    导包：import java.util.Scanner;

    创建对象：Scanner sc = new Scanner(System.in);

    接收数据：int x = sc.nextInt();

    package dades;
import java.util.Scanner;
public class index {
	public static void main(String[] xudsad){
		//创建键盘录入数据的对象
		Scanner sc = new Scanner(System.in);	
		//接收数据
		System.out.println("请录入一个整数：");
		int i = sc.nextInt();	
		//输出数据
		System.out.println("i:"+i);
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    if判断

    int a = 12;
int b = 11;
if(a == b){
	System.out.println("等于");
}
else if(a > b){
	System.out.println("大于");
}
else{
	System.out.println("不等于");
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    switch语句

    ​

    int weekday = 7;//输入几走几
switch(weekday) {
case 1:
	System.out.println("星期一");
	break;
case 2:
	System.out.println("星期二");
	break;
case 3:
	System.out.println("星期三");
	break;
case 4:
	System.out.println("星期四");
	break;
case 5:
	System.out.println("星期五");
	break;
case 6:
	System.out.println("星期六");
	break;
case 7:
	System.out.println("星期日");
	break;
default:
	System.out.println("你输入的数字有误");
	break;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27

    for循环

    for(int x=1; x<=11; x++) {
	System.out.println("HelloWorld");
}

    • 1
    • 2
    • 3
    int ss = 0;
for(int x=1; x<=11; x++) {
	ss = x;
}
System.out.println(ss);

    • 1
    • 2
    • 3
    • 4
    • 5

    while循环

    while(判断条件语句) {

    ​ 循环体语句;

    ​ 控制条件语句;

    }

    int x=1;
while(x<=10) {
	System.out.println("HellloWorld");
	x++;
}

    • 1
    • 2
    • 3
    • 4
    • 5

    跳出循环

    break跳出单层循环

    continue退出本次循环

    随机数

    – 导包

    • import java.util.Random;

    – 创建对象

    • Random r = new Random();

    – 获取随机数

    • int number = r.nextInt(10);

    数组

    获得长度.length

    int[] arr = {1,2,3};
//输出数组名和元素
System.out.println(arr[0]);

    • 1
    • 2
    • 3
    //定义一个数组
int[] arr = new int[3];
arr[0] = 100;

    • 1
    • 2
    • 3

    二维数组

    int[][] arr = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };
int s = arr[0][0];

    • 1
    • 2

    函数与方法

    package dades;
import java.util.Scanner;

public class index {
	public static int sem(int a,int b){
		return a+b;
	}
	public static void main(String[] xudsad){
		int sum = sem(10,20);
		//调用方法输出
		System.out.println(sum);
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    面向对象

    调用对象格式：类名 对象名 = new 类名();
对象如何访问成员呢?
成员变量：对象名.变量名
成员方法：对象名.方法名(...)

    • 1
    • 2
    • 3
    • 4
    package dades;
import java.util.Scanner;

public class index {
	String name;
	int age;
	public static void sem(int b){
		for(int s=1;s<=10;s++){
			System.out.println(b);
		}
	}
	public static void main(String[] xudsad){
		sem(10);
		System.out.println(666);
		System.out.println(666);
		System.out.println(666);
		System.out.println(666);
		System.out.println(666);
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    package dades;

public class indexDemo {
	public static void main(String[] xu){
		index in = new index();
		in.name = "dade";
		in.age = 18;
		System.out.println(in.name);
		System.out.println(in.age);
		in.sem(10);
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    封装，修饰符

    private最常见应用

    A:把成员变量用private修饰

    B:提供对应的getXxx()/setXxx()方法

    private修饰的成员只在本类中才能访问。
private int age;
针对private修饰的成员变量，我们会相应的提供getXxx()和setXxx()用于获取和设置成员变量的值,方法用public修饰

	public void setAge(int a) {
		if(a<0 || a>200) {
			System.out.println("你给的年龄有误");
		}else {
			age = a;
		}
	}
	
	public int getAge() {
		return age;
	}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    package dades;
import java.util.Scanner;

public class index {
	String name;
	private int age;
	public void setAge(int a){
		this.age = a;
	}
	public int getAge(){
		return age;
	}
	public void sem(int b){
		System.out.println(age);
	}
}


package dades;
public class indexDemo {
	public static void main(String[] xu){
		index in = new index();
		in.name = "dade";
		in.setAge(10);
		in.sem(10);
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27

    this是封装

    构造方法

    主要用来给对象的数据进行初始化

    A:构造方法格式

    a:方法名与类名相同

    b:没有返回值类型，连void都没有

    c:没有具体的返回值

    public class Student {	
	public Student() {
		System.out.println("这是构造方法");
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5

    如何调用构造方法呢?

    格式：类名 对象名 = new 构造方法(...);
Student s = new Student();

    • 1
    • 2

    方法注意事项与重载

    如果你不提供构造方法，系统会给出默认构造方法

    如果你提供了构造方法，系统将不再提供

    构造方法也是可以重载的,重载条件和普通方法相同

    public class Student {
	private String name;
	private int age;
	//构造方法
	public Student() {}
	public Student(String name,int age) {
		this.name = name;
		this.age = age;
	}
	public void show() {
    	System.out.println(name+"---"+age);
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    package com.itheima_08;
public class StudentDemo {
	public static void main(String[] args) {
		Student s1 = new Student("林青霞",28);
		s1.show();
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    构造方法自动

    /*
 \* 自动生成构造方法：
 \* 		代码区域右键 -- Source -- Generate Constructors from Superclass...	无参构造方法
 \* 		代码区域右键 -- Source -- Generate Constructor using Fields...		带参构造方法
 \* 自动生成getXxx()/setXxx():
 \* 		代码区域右键 -- Source -- Generate Getters and Setters...
 */

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    对象数组

    public static void main(String[] xu){
	index[] s = new index[3];
	index in = new index("大得",18);
	index in1 = new index("大得1",18);
	index in2 = new index("大得2",18);
	
	s[0] = in;
	s[1] = in1;
	s[2] = in2;
	
	for(int x=0;x
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    集合之ArrayList

    添加新元素add

    ArrayList array = new ArrayList();
array.add("dade");
array.add("18");
System.out.println(array);

-----------
[dade, 18]

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    删改查方法（遍历）

    查：System.out.println(array.get(0));
查多少个：System.out.println(array.size());
删除指定元素：System.out.println(array.remove("dade"));
删除指定索引：array.remove(0)
修改：System.out.println(array.set(0,"dade"));

遍历：
for(int x=0; x
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    IO流（操作文件）

    写入

    package dades;

import java.io.FileWriter;
import java.io.IOException;

public class indexDemo {
	public static void main(String[] xu) throws IOException{
		//快捷键ctrl+shift+o导包，在抛出异常
		FileWriter fw = new FileWriter("d:\\1\\a.txt");
		fw.write("IO流你好");
		//刷新
		fw.flush();
		//关闭
		fw.close();
	}
}

写多条
FileWriter fw = new FileWriter("d:\\1\\a.txt");
fw.write("helloworld");
fw.flush();
fw.write("java");
fw.flush();
//关闭
fw.close();

追加
FileWriter fw = new FileWriter("c.txt",true); //表示追加写入，默认是false
fw.write("IO流你好");
fw.write("IO流你好");
fw.close();

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31

    读文件

    FileReader

    package dades;

import java.io.FileReader;
import java.io.IOException;

public class indexDemo {
	public static void main(String[] xu) throws IOException{
		FileReader fr = new FileReader("d:\\1\\a.txt");
		int ch;
		while((ch=fr.read())!=-1) {
			System.out.print((char)ch);
		}
		//释放资源
		fr.close();
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    缓冲流

    写入
    package dades;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class indexDemo {
	public static void main(String[] xu) throws IOException{
		BufferedWriter bw = new BufferedWriter(new FileWriter("d:\\1\\a.txt"));
		bw.write("hello11");
		//bw.flush();
		bw.close();
	}
}


//一次读写一个字符
int ch;
while((ch=br.read())!=-1){
	System.out.print((char)ch);
}

		
//一次读写一个字符数组
char[] chs = new char[1024];
int len;
while((len=br.read(chs))!=-1) {
	System.out.print(new String(chs,0,len));
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    读出
    package dades;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class indexDemo {
	public static void main(String[] xu) throws IOException {
		BufferedReader br = new BufferedReader(new FileReader("d:\\1\\a.txt"));
		int ch;
		while((ch=br.read())!=-1){
			System.out.print((char)ch);
		}
	}
}


一次读一行
BufferedReader br = new BufferedReader(new FileReader("d:\\1\\a.txt"));
String line;
while((line=br.readLine())!=null) {
	System.out.println(line);
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23

    static静态

    访问静态成员的格式:
类名.静态成员变量名
类名.静态成员方法名(参数)

class Person {
	String name;
	int age;
	static String graduateFrom;//静态成员定义
}

public static void main(String[] args) {
		//不用new，直接使用，修改全部一样
		Person.graduateFrom = "大得";
		System.out.println(Person.graduateFrom);
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    代码块

    //局部代码块：存在于方法中，控制变量的生命周期（作用域）
{
	for(int x = 0;x < 10;x++) {
		System.out.println("我爱Java");
	}
	int num = 10;
}
//System.out.println(num);//无法访问num,超出num的作用域范围，代码块外无法访问


//静态代码块：随着类的加载而加载，只加载一次，加载类时需要做的一些初始化，比如加载驱动
//对象代码块每创建一个对象均会执行一次构造代码块。
static {
	System.out.println("我爱Java");
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    继承

    class 子类 extends 父类 {}

    • 1

    方法重写：@Override：方法重写，说明下面的方法是重写父类的方法

    class NewPhone extends Phone {
	@Override
	public void call() {
		System.out.println("录音");		
	}
}

this:当前对象的引用
调用子类的成员变量
调用子类的成员方法
在子类的构造方法第一行调用子类其他构造方法
super:子类对象的父类引用
调用父类的成员变量
调用父类的成员方法
在子类的构造方法第一行调用父类的构造方法

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    抽象类

    抽象类和抽象方法必须被abstract修饰

    一个类继承了抽象类要么重写所有的抽象方法，要么他自己是抽象类

    abstract class Animal2 {
	public abstract void eat();
	public void run() {

	}
}

class Cat2 extends Animal2 {
	@Override
	public void eat() {
		// TODO Auto-generated method stub	
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    接口

    与定义类的class不同，接口定义时需要使用interface关键字
public interface 接口名 {
    抽象方法1;
    抽象方法2;
    抽象方法3;
}

接口中的方法全是抽象方法,直接new接口来调用方法没有意义,Java也不允许这样干
类与接口的关系为实现关系，即类实现接口。实现的动作类似继承，只是关键字不同，实现使用implements
其他类(实现类)实现接口后，就相当于声明：”我应该具备这个接口中的功能”。实现类仍然需要重写方法以实现具体的功能。
格式：
class 类 implements 接口 {
	重写接口中方法
} 

1、接口中可以定义变量，但是变量必须有固定的修饰符修饰，public static final 所以接口中的变量也称之为常量，其值不能改变。后面我们会讲解fnal关键字
2、接口中可以定义方法，方法也有固定的修饰符，public abstract
3、接口不可以创建对象。
4、子类必须覆盖掉接口中所有的抽象方法后，子类才可以实例化。否则子类是一个抽象类。

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    包和修饰符（导入）

    导包的格式：
import 包名.类名;

权限修饰符	
	                         public	protected	default	private
同一类中	                      √  	√	       √	   √
同一包中(子类与无关类)	          √	    √	       √	
不同包的子类                     	√	  √		
不同包中的无关类	               √			

A:要想仅能在本类中访问使用private修饰
B:要想本包中的类都可以访问除了private修饰符,其它都可以
C:要想本包中的类与其他包中的子类可以访问使用protected修饰
D:要想所有包中的所有类都可以访问使用public修饰。

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    时间

    导入import java.util.Date;
import java.text.SimpleDateFormat;

获得时间戳
Date a = new Date();
System.out.println(a.getTime());
当前时间
SimpleDateFormat formatter= new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date = new Date(System.currentTimeMillis());
System.out.println(formatter.format(date));


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    集合

    ArrayList list = new ArrayList();

    import java.util.ArrayList;

//创建集合对象
ArrayList al = new ArrayList();
//添加元素
al.add("hello");
al.add("world");
al.add("java");
//遍历集合
for(int x = 0;x < al.size();x++) {
	System.out.println(al.get(x));
}
//将集合转换成一个Object类型的数组
Object[] objs = al.toArray();
for (int i = 0; i < objs.length; i++) {
	System.out.println(objs[i]);
}


//创建集合对象
Collection c = new ArrayList();
//添加元素
c.add("hello");
c.add("world");
c.add("java");
//遍历
for (String string : c) {
	System.out.println(string);
}


//创建集合对象HashSet集合
HashSet hs = new HashSet();
//创建元素对象
Student s = new Student("zhangsan",18);
Student s2 = new Student("lisi",19);
Student s3 = new Student("lisi",19);
//添加元素对象
hs.add(s);
hs.add(s2);
hs.add(s3);
//遍历集合对象
for (Student student : hs) {
	System.out.println(student);
}

HashSet hs = new HashSet();
//创建元素对象
Person p = new Person("zhangsan",18);
Person p2 = new Person("lisi",18);
Person p3 = new Person("lisi",18); 
//添加元素对象
hs.add(p);
hs.add(p2);
hs.add(p3);
//遍历集合对象
for (Person person : hs) {
	System.out.println(person);
}

//HashMap集合
Map map = new HashMap();
System.out.println(map.put("ITCAST001", "张三"));
System.out.println(map.put("ITCAST002", "李四"));
System.out.println(map.put("ITCAST001", "王五"));

		//创建Map对象
		Map map = new HashMap();
		//添加映射关系
		map.put("谢婷疯", "张箔纸");
		map.put("陈关西", "钟欣桶");
		map.put("李亚碰", "王飞");
		//遍历Map对象
		
		//首先召集所有的丈夫
		Set keys = map.keySet();
		//遍历所有的丈夫
		for (String key : keys) {
			//让每个丈夫去找他自己的媳妇就可以了
			String value = map.get(key);
			System.out.println("丈夫：" + key + "---" + "媳妇：" + value);
		}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82

    异常

    try {
	//需要被检测的语句。
}
catch(异常类 变量) { //参数。
	//异常的处理语句。
}
finally {
	//一定会被执行的语句。
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
  • 相关阅读:
    c++ ofstream 和ifstream 读写二进制文件的简单操作
    Lab: Xv6 and Unix utilities
    互联网图片安全风控实战训练营开营！
    鸿蒙应用模型开发-更新SDK后报错解决
    U盘目录穿越获取车机SHELL - 分析与复现
    BTree vs B+Tree 节点操作流程图解
    SQL每日一练（牛客新题库）——第6天：必会常用函数
    一篇文章让你理解 大数据所需要的组件
    Linux MySQL-v8.0.30的安装与配置
    centos 部署nginx 并配置https
  • 原文地址：https://blog.csdn.net/qq_34631220/article/details/128171888