JAVA 初阶

本文主要是介绍JAVA 初阶，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

安装

1. JAVA JDK 和JRE区别
   JDK：java development kit （java开发工具）
   JRE：java runtime environment （java运行时环境）
   引申出JVM
   JVM：java virtuak machine （java虚拟机）
2. eclipse使用

配置Edit plus 编译器环境

首先明确javac.exe是用来编译软件的
Java.exe是用来运行Java程序的
配置说明参考这篇文章

IDEA 软件

Project——Module——Package

入门

主类结构

1. Java程序的基本组成是类，文件名必须与类名相同。
2. Class XXX

文件名前*代表文件未保存
查看正在运行着的程序（防止死机）

2. print与println

printf主要是继承了C语言的printf的一些特性，可以进行格式化输出

print就是一般的标准输出，但是不换行

println和print基本没什么差别，就是最后会换行
————————————————0518

注释

单行注释：
多行注释：
文档注释：

关键字、标识符、包

———————————————0519

变量

1. 变量使用之前必须赋值；

数据类型

布尔类型（不可进行计算）
浮点类型：

1. float 数据后加F
2. Double 浮点数默认是double

逻辑运算

区分&& 与 & ,
3. 三元表达式（十分有用，做条件判断）
需要定义布尔类型 Boolean 类型
比较最大值

/*int x=10;
			int y=10;
			boolean b=(x==y) ? true:false;//定义布尔类型变量
			/*int z;
			z=(x>y)?x:y;*/
			
			max= (a>b) ? a:b;
			max= (max>c) ? max:c;

键盘录入

import java.util.Scanner; //导包，注意位置在class上面，导入包中的类Scanner
class demo_scanner 
{
	public static void main(String[] args) 
	{
		Scanner sck =new Scanner(System.in);   //创建键盘录入对象
		System.out.println("请输入一个整数：");
		int x = sck.nextInt();			//将键盘录入的数据存储在x中
		System.out.println(x);
	}
}

流程控制语句

顺序结构

选择结构

• 报错问题待解决——找不到字符

问题原因：System.out.printIn©;中 l 应为小写的L
nextInt() 中的 I 为大写的 i;
是不是很坑啊！！！！

• 在命令行窗口执行程序时出现乱码：
  
  可以尝试更换程序编码方式：改为系统默认

多重if嵌套

if(x==1){
			System.out.println("男厕所欢迎你");
		}else if (x==0)
		{			System.out.println("女厕所欢迎你");
		}else{
			System.out.println("无法识别你的性别");
		}

switch语句

switch（表达式）{  //基本数据类型可以接受 byte,short,char ,int
	case 值1 ：		//引用可以接受枚举和string字符串
	语句体1;
	break;
	case 值2 ：
			...
	default:
	

String XXX=“ ”；——定义字符串

循环结构

1. 统计思想
   变量先赋零，满足条件再自加加
2. for
3. while
4. do…while
5. 无限循环
6. 区分print与println
7. 转义字符

8. continue&break语句
   break和continue都是用来控制循环结构的，主要是停止循环。

break
　　　　有时候我们想在某种条件出现的时候终止循环而不是等到循环条件为false才终止。
　　　　这时我们可以使用break来完成。break用于完全结束一个循环，跳出循环体执行循环后面的语句。

var str = "hello";
for (var item of str){
    if(item ==="l"){
        break
    }
    console.log(item);  // h e 
}

continue
　　　　continue和break有点类似，区别在于continue只是终止本次循环，接着还执行后面的循环，break则完全终止循环。

可以理解为continue是跳过当次循环中剩下的语句，执行下一次循环。

var str = "hello";
for (var item of str){
    if(item ==="l"){
        continue
    }
    console.log(item);  // h e o
}

• mark

• return

方法概述和格式说明

• 格式
  如何写方法
  1、明确返回值类型
  2、明确参数列表
• void ——无返回值
  
• 修饰符： public static 固定写法 返回值类型： 表示方法运行的结果的数据类型，方法执行后将结果返回到调用者
• 参数列表：方法在运算过程中的未知数据，调用者调用方法时传递 return：将方法执行后的结果带给调用者，方法执行到return
• 整体方法运行结束 小贴士：return 结果; 这里的"结果"在开发中，我们正确的叫法成为方法的返回值

练习：比较最大值

import java.util.Scanner;
class test_method1 
{
	public static void main(String[] args) 
	{
		System.out.println("Please enter the first number:");
		Scanner sc=new Scanner(System.in);
		int x =sc.nextInt();
		System.out.println("Please enter the second number:");
		int y=sc.nextInt();
		//int c=max(x,y);

		System.out.println("The maxist one is:"+max(x,y)); //注意：返回值是void方法，即返回值为空时不能输出调用

	}
	public static int max(int a,int b){
		/*if (a>b)
		{
			return a;
		}else{
			return b;
		}*/
		return a>b ?a : b;    //简化方法，三元选择语句
	}
}

方法重载和基本使用

方法重载：指在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同即可，与修饰符和返
回值类型无关。
参数列表：个数不同，数据类型不同，顺序不同。
重载方法调用：JVM通过方法的参数列表，调用不同的方法。

数组

格式：
int [ ] arr(数组名字为arr) =new int[5]
数组定义格式详解：

• 数组存储的数据类型： 创建的数组容器可以存储什么数据类型。 [] : 表示数组。

• 数组名字：为定义的数组起个变量名，满足标识符规范，可以使用名字操作数组。

• new：关键字，创建数组使用的关键字。

• 数组存储的数据类型： 创建的数组容器可以存储什么数据类型。

• [长度]：数组的长度，表示数组容器中可以存储多少个元素。
  注意：数组有定长特性，长度一旦指定，不可更改。

数组的初始化

Java虚拟机内存划分（不太懂）

1. 堆中 数组地址值赋给栈中的main方法，
2. new一次，堆里会新增一个地址和空间；

数组静态初始化

数组越界和异常

1、arr=NULL; 数组覆盖为空

数组遍历

1. 数组长度
   arr.length

练习：获取数组中的最值

//获取数组中的最值
class array_max 
{
	public static void main(String[] args) 
	{
		int[] arr={22,33,66,11,99};

		System.out.println("最大值是："+getMax(arr));
	}
	public static int getMax(int[] arr){       //定义最值方法，有返回值不用void
		int max = arr[0];
		for(int i=1;i<arr.length;i++){			//获取数组长度的方法
			if(max<arr[i]){
				max=arr[i];
			}
		}
		return max;					//记住一定要有返回值
	}
}

练习：交换翻转数组元素

//将数组元素对调
class array_reverse 
/*{
	public static void main(String[] args) 
	{
		int [] arr={12,22,33,44,66};
	
        reverse(arr);
		System.out.println("------------------------------");
		for(int i=0;i<arr.length;i++){
		System.out.println(arr[i]);
		}
	}
	public static void reverse(int [] arr){
		int a =arr.length;
		int[] arr1=new int[a];
		for(int i=0;i<a;i++){
			arr1[i]=arr[a-i-1];
		}
		for(int i=0;i<a;i++){
			arr[i]=arr1[i];
			System.out.print(arr[i]+"\t");
	}
	}
}
*/


//参考程序

{
	public static void main(String[] args){
		int[] arr={11,22,33,44,55,66};
		reverse(arr);
		print(arr);				//一定要记得调用函数，否则不会有输出结果

	}


	public static void reverse(int[] arr){
		for(int i=0;i<arr.length/2; i++){
			//将arr[o]与arr[arr.length -1]进行交换
			int temp= arr[i];
			arr[i]=arr[arr.length-1-i];
			arr[arr.length-1-i]=temp;
		}
	}
	public static void print(int[] arr){
		for(int i=0;i<arr.length;i++){
			System.out.print(arr[i] + " ");
		}
	}

}

练习：星期输出

import java.util.Scanner;
class getday 
{
	public static void main(String[] args) 
	{
		Scanner sc=new Scanner(System.in);
		int week =sc.nextInt();
		System.out.println("您输入的是星期"+get(week));
	}
	public static char get(int day){
			char[] arr={' ','一','二','三','四','五','六','七'};   //注意字符类型数组的创建方式
			return arr[day];
	}
}

数组元素基本查找

二维数组

定义

int [][] arr= new int[3][2];

二维数组的遍历

class array2search 
{
	public static void main(String[] args) 
	{
		int[][] arr={{1,2,3},{4,5},{6,7,8,9}};
		for(int i=0;i<arr.length;i++){						//获取每个二维数组中的一维数组
			for(int j=0;j<arr[i].length;j++){				//获取一维数组中的各元素
				System.out.print(arr[i][j]);
			}
			System.out.println();     //打印完一行再换行
		}
	}
}

练习：数组冒泡排序（Key point！）

class arrbubble
{
	public static void main(String[] args) 
	{
		int[] arr={11,45,23,66,54};
		for(int i=1;i<arr.length;i++){   //比较相邻两个元素，较大的往后冒泡
			for(int j=0;j<(arr.length-i);j++){
				if(arr[j]<arr[j+1]){
					int temp=arr[j];
					arr[j]=arr[j+1];
					arr[j+1]=temp;
				}
			}
		}
		print(arr);
		System.out.println("This future!!!");
	}
	public static void print(int [] arr){  //遍历数组
		for(int i=0;i<arr.length;i++){
			System.out.print(arr[i]+" ");
		}
	}
}

Java是传值还是传地址（待解决）

面向对象

定义（第一次不好理解）

主要区分于面向过程，就是一步一步地执行
Java程序语言在一个个对象里面运行，即封装好

1. 类
   物以类聚，人以群分；
   类是抽象概念，对象是抽象概念的具体化，例如：班上所有同学同属 学生这一大类，而每个学生又是一个个性鲜明的对象
2. 类的特点
   属性——对象（成员）的变量（特点）
   行为——成员行为、方法（能够执行什么）

class phone{
	String brand;
	int price;							//定义属性
	public void call{
	System.out.println("打电话");		//定义行为
	}
}

类的创建示例

3. 类的创建和使用

class demo_student 
{
	public static void main(String[] args) 
	{
		//创建对象的格式：类名  对象名=new 类名（）；
		//对象名：其实就是合法的标识符
		Student s=new Student();  //注意后面右括号
		//使用成员变量：对象名.变量名
		s.name="张三";
		s.age=23;
		s.study();
		s.sleep();
		System.out.println(s.name+"...."+s.age);	//注意输出方法
	}
}

class Student
{
	String name;
	int age;
	String gender;

	public void study(){
		System.out.println("学生学习");
	}

	public void sleep(){

		System.out.println("学生睡觉");
	}

}

内存图

栈——堆——方法区

形式参数

应用数据类型作为形式参数

Student s=new Student();

public static void print(Student) //这里就是引用数据类型，引用类型传递的是地址，可以用 使用成员变量：对象名.变量名 调用其属性

public static void print(int x) //这里就是基本数据类型

匿名对象

new 类名（）.方法名();
适用场合：匿名对象只适合对方法的一次调用，
注意：匿名对象不可调用属性，或者说调用没有意义，调用后地址没有进入栈中，会被当做垃圾处理。

封装

把属性隐藏，提高安全性

private关键词

class demo_private 
{
	public static void main(String[] args) 
	{
		Person p1= new Person();
		p1.name="小土豆";
		p1.setAge(-18);
		System.out.println(p1.getAge());
	}
}

class Person
{
	String name;
    private int age;

	public void setAge(int a){
		if(a>0 && a<100){
				age=a;
		}else{
				System.out.println("你可以死几次了");
		}
	}

	public int getAge(){
			return age;
	}	
}

• 封装优化1 ——this 关键词 （待解决）
  this的含义
  this代表所在类的当前对象的引用（地址值），即对象自己的引用。
  记住 ：方法被哪个对象调用，方法中的this就代表那个对象。即谁在调用，this就代表谁。

private使用格式

1、使用private修饰成员 变量
2、提供 getXXX方法 和 setXXX方法，可以访问成员变量

封装优化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 class ClassName{
//成员变量
//构造方法
	//无参构造方法【必须】
	//有参构造方法【建议】
//成员方法
//getXxx()
//setXxx()
}

练习：输出长方形周长面积

class  test_rectangle
{
	public static 2void main(String[] args) 
	{
		Rectangle r=new Rectangle(10,20);   //调用并构造新对象
		System.out.println(r.getLength());
		System.out.println(r.getArea());
		System.out.println("This future!!!");
	}
}

//定义一个长方形类，定义求周长、面积的方法
class Rectangle
{
	private int width;
	private int high;

	public Rectangle(){}			//	空参构造

	public Rectangle(int width,int high){
				this.width=width;				//有参构造
				this.high=high;
	}

	public void setWidth(int width){
			this.width=width;
	}

	public int getWidth(){
			return width;
	}

	public void setHigh(int high){
			this.high=high;
	}

	public int getHigh(){
			return high;
	}

	public int getLength(){				//获取周长
			return 2*(width+high);
	}

	public int getArea(){				//获取面积
			return width*high;
	}


}

static关键字

1、通俗来说：加了static后，所有关键词赋值一次，即可重复调用，多个对象共享一个属性值
关于 static 关键字的使用，它可以用来修饰的成员变量和成员方法，被修饰的成员是属于类的，而不是单单是属于某个对象的。也就是说，既然属于类，就可以不靠创建对象来调用了。

2、使用特点
共性用静态，个性用非静态。
可以使用类名调用。

Person p1 =new Person();						//创建对象
		p1.name="泰勒斯威夫特";
		p1.coun="加拿大";									//调用对象的属性
		//静态关键字也可使用类名调用  Person.coun="USA";(无需创建对象）
		p1.speak();													//输出完成后弹栈

3、注意事项

class demo_static2 
{
	public static void main(String[] args) 
	{
		demo d= new demo();
		d.print2();
	}
}

class demo
{
	int num1=10;
	static int num2=20;

	/*public void print1(){						//非静态成员方法，既可以访问静态也可以访问非静态
		System.out.println(num1);
		System.out.println(num2);*/

	public static void print2(){
		System.out.println(num1);     //静态的成员方法无法访问非静态的，报错。因为静态方法可以不创建对象，非静态建立在对象之上
		System.out.println(num2);
	
	}
}

静态变量与成员变量

主方法

1、public
static
void
main
String[] args: args 代表参数

工具类Array Tool

• 找不到符号

 程序1

class demo_ArrayTool 
{
	public static void main(String[] args) 
	{
		int[] arr={33,22,66,11,44,55};
		ArrayTool aa = new ArrayTool();
		int max=aa.getMax(arr);
		System.out.println(max);
	}
}

程序2

class ArrayTool 
{
	
	//1 获取最大值
	public  int getMax(int[] arr){
		int max=arr[0];
		for(int i=1;i<arr.length;i++){
				if(arr[i]>max){
						max=arr[i];
				}
		}
		return max;		//将最大值返回
	}

	public void print(int[] arr){
		for(int i=0;i<arr.length;i++){						//遍历数组
			System.out.print(arr[i]+"   ");
		}
	}


	public void revArray(int[] arr){
		for(int i=0;i<arr.length/2;i++){
			int temp=arr[i];
			arr[i]=arr[arr.length-1-i];
			arr[arr.length-1-i]=temp;

		}
	}
}

程序放在一块能运行

文档说明书

软件说明注释```

math库

math库官方文档
random ——随机数生成
不需要进行库的引用

练习——生成1-100随机数

class  demo2_Math
{
	public static void main(String[] args) 
	{
		
		for(int i=0;i<10;i++){
				System.out.println((int)(Math.random()*100)+1);//注意这里生成随机数的方法
		}

		//生成1—100随机数
	}
}

代码块

局部代码块

构造代码块

每创建一次对象就会执行一次，优先于函数执行
将多个代码块中系统部分放到一起，避免重复调用

静态代码块

优先于主方法执行
随着类加载而加载，执行一次

class demo_code 
{
	public static void main(String[] args) {
		{
			int x=10;				//限定变量的声明周期
			System.out.println(x);
		}
		Student s1=new Student();     //调用空参对象
		System.out.println("*********************************");
		Student s2=new Student("Future",22);   //调用有参对象
	}
}


class Student
{
	private String name;
	private int age;

	public Student(){
		System.out.println("*空参构造");
	}     //空参构造


	public Student(String name,int age){//有参构造
			this.name=name;
			this.age=age;
			System.out.println("*有参构造");
	}

	public void setName(String name){
		this.name=name;
	}
	public String getName(){
		return name;
	}


	public void setAge(int age){
		this.age=age;
	}
	public int getAge(){
		return age;
	}
	{		//构造代码块：每创建一次对象就会执行一次，优先于函数执行
		System.out.println("*构造代码块");
	}
	static{
		System.out.println("静态代码块");   //随着类的执行而执行，且只执行一次
	}		//作用：用来给类做初始化，一般用来加载驱动；优先于主方法执行

}

总结：执行顺序：主方法类中的静态代码块（执行一次）
主方法（执行一次）
静态代码块（执行一次）
构造代码块
构造方法（调用多次，执行多次）

继承（extends）

1、提高代码复用性
2、extends 继承父类的属性，可以理解为是对模板的引用和调用

格式 class 个体名 extends 父类名
3、好处

1. 提高代码的复用性。
2. 类与类之间产生了关系，是多态的前提。

缺点：耦合性特别强

1. 开发原则：高内聚，低耦合
2. 耦合：类与类之间的关系

继承的特点

3. Java只支持单继承，不支持多继承。
4. Java支持多层继承(继承体系)
   class A{}
   class B extends A{}
   class C extends B{}
   用所有功能——最底层的类创建B；看共性功能——最顶层 A --------05
5. 注意事项
   1、子类只能继承父类所有非私有的成员（非private）
   2、子类不能继承父类的构造方法，可以通过super关键字去访问

这篇关于JAVA 初阶的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！