Java复习

最新推荐文章于 2024-08-15 14:47:41 发布

inn-inn

最新推荐文章于 2024-08-15 14:47:41 发布

阅读量309

点赞数 12

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/m0_65787494/article/details/124599424

版权

Java 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

#Java复习

Java是一个面向对象的语言，下面介绍Java的基本语法知识

第一个Java程序

修饰符 class 类名{
           public static void main(String[] args){
               System.out.println("第一个Java程序")；
            }
       }

注释

1.单行：int a=3; //定义一个整型变量
2.多行：/* int a=0;
int b=9;*/
多行注释可以嵌套使用单行注释，不能嵌套使用多行注释
3.文档注释：/**
* @author黑马程序员
* @version 1.0
* /

标识符（拼写规范）

包pacage中所有字母必须小写。例如：cn.test;
类名和接口中的首字母必须大写，例如：ArryList
常量名中的所有字母都大写，单词之间用下划线连接，例如：DAY_OF_MONTH
变量名和方法名的第一个单词首字母小写，从第二个单词开始每个单词首字母都大写，例如：lineNumber，getLineNumber；
尽量使用有意义的英文单词定义标识符，使得程序便于阅读，例如：useName定义用户名。

关键字

关键字类别，具体的下面会一一解释

Java中的常量

整型、浮点数、字符常量、字符串、布尔常量、null常量；
其中：布尔常量有true和false，用于区分事物真假
null只有一个值null表示对象的引用为空

Java中的变量

Short占用16位（2字节）
int占用32位（4字节）
long占用64位（8字节）在为long型变量赋值时，值后面要加字母L/l，但如果数值范围未超过int型范围，也可不加L/l;
浮点数变量
float占用32位（4字节），double占用64位（8字节）
浮点数定义时默认是double类型，在为浮点数类型变量赋值时，float后边必须加F/f，double可以加D/d。
字符型变量
存储单一字符，占用2字节。
char c=’a’;
char ch=97;//根据Unicode，ch为字符a
布尔型变量
boolean flag=false;
flag=ture;

变量类型转换

自动转换（隐式类型转换）：编译器自动完成
- [ 条件] 1.两种数据类型彼此兼容
- 2.目标类型的取值范围大于源类型的取值范围
byte b=3; int x=b;
三种情况：（1）整数之间类型转换
（2）整数转换为float类型
（3）其他类型转换为double类型。
.强制类型转换（显示类型转换）：
int num=4；
byte b=(byte) name;

方法

定义一个方法的语法格式：

修饰符 返回值类型 方法名{方法名 参数名1，参数类型 参数名2}{
        执行语句
        return 返回值;
      }

方法的重载：在同一个作用域内，方法名相同但是参数个数及参数类型不同。（多次写）

数组

一维数组：
声明方式：

1.数组类型[ ] 数组名； 数组名=new 数组类型[长度]；
2.数组类型[] 数组名=new类型[](元素，元素);
3.数组类型[] 数组名=new类型[](元素，元素);
4.类型[] 数组名={元素，元素};

简单使用：

int arr[] = new int[3];
    System.out.println(“arr[0]=”+arr[0]);

                     **不同数据类型默认初始值**

数据类型	默认初始值
byte,short,int,long	0
float,double	0.0
char	一个空字符，即’\u0000’
boolean	false
引用数据类型	null,表示变量不引用任何对象

二维数组：
使用：

      数据类型[ ][ ] 数组名=new 数据类型[行数][列数（可不写）]；
      数据类型[ ][ ] 数组名={{第0行初始值}，{第2行初始值}……}

数组常见操作：
（1）数组的遍历：

public class test {
    public static void main(String[] args)
        int[] arr= {1,2,3,4};//定义数组
    	//使用for循环遍历数组元素
    	for(int i = 0;i<3;i++) {
    	    System.out.println(arr[i]);//通过索引访问元素
            }
}

（2）数组中最值的获取

public class test {
    public static void main(String[] args) {
      	int[] arr= {1,2,3,4};//定义数组
        //定义变量max用于记住最大值，首先记录第一个元素为最大值
        int max = arr[0];
     	//遍历数组，查找最大值
     	for(int i =0;i<arr.length;i++) {
    	    //比较arr[i]的值是否大于max
    		if(arr[i]>max) {
    		     //条件成立，将max的值赋给max
    			 max=arr[i];
    			 }
      	 }
    	 System.out.println("数组arr中的最大值是："+max);//打印最大值
     } 
}

（3）在数组指定位置插入一个数据

public class test {
    public static void main(String[] args) {
    	int[] arr= {10,11,13,14,15};//定义数组
    	int score=12;
    	//定义一个比arr数组长度大1的新数组
    	int[] arr2= new int[arr.length+1];
    	//将arr拆分成两部分，将12插入到，拆分后的两个数组中间
    	for(int i=0;i<3;i++) 
    	{
    		arr2[i]=arr[i];
    	}
    	arr2[2]=score;
    	for(int i=3;i<arr2.length;i++)
    	{
    		arr2[i]=arr[i-1];
    	}
    	System.out.println("添加元素之前的arr数组：");
    	for(int i=0;i<arr.length;i++) 
    	{
    		System.out.print(arr[i]+",");
    	}
    	System.out.println(" ");
    	System.out.println("添加元素之后的arr2数组：");
    	for(int i=0;i<arr2.length;i++) 
    	{
    		System.out.print(arr2[i]+",");
    	}
    } 
}

（4）数组排序

public class test {
    public static void main(String[] args) {
    	int [] arr= {9,8,3,5,2};
    	//冒泡排序前，先循环打印数组元素
    	for(int i=0;i<arr.length;i++) 
    	{
    		System.out.print(arr[i]+" ");
    	}
    	System.out.println(" ");
    	//进行冒泡排序
    	//外层循环定义需要比较的轮数（两数比较，要比较n-1轮）
    	for(int i=0;i<arr.length;i++) 
    	{
    		//内层的循环定义第i轮需要比较的两个数
    		for(int j=0;j<arr.length-1;j++) 
    		{
    			if(arr[j]>arr[j+1]) 
    			{   //比较相邻的两个元素
    				//下面三行代码用于交换相邻两个二元素
    				int temp=arr[j];
    				arr[j]=arr[j+1];
    				arr[j+1]=temp;
    			}
    		}
    	}
    	//完成冒泡排序之后，再次循环打印数组元素
    	for(int i=0;i<arr.length;i++) 
    	{
    		System.out.print(arr[i]+" ");
    	}
    } 
}

✨实现结果

9 8 3 5 2
2 3 5 8 9

类与对象

Java中类和对象是最基本、最重要的单元。类是Java中一个重要的引用数据类型，也是组成Java程序的基本要素，所有Java程序都是基于类的。类是对象的抽象，用于描述一组对象的共同特征和行为。

类的定义格式

class 类名{
   成员变量；
   成员方法；
}

*eg:*定义一个Student（学生）类，成员变量包括name（名字），age（年龄），sex（性别）；成员方法包括读书read( )。Student类定义的示例代码：

class Student{
	String name;
	int age;
	String sex;
	//定义read方法
	void read() 
	{
         String name ="张三"；
		System.out.print("大家好，我是"+name+",我在看书！");
	}

对象的创建与使用

类名 对象名=null;
对象名  = new 类名（）;
类名 对象名 = new 类名（）;

  示例代码

class Student{
	String name;
	//定义read方法
	void read() 
	{
		System.out.println("大家好，我是"+name+",我在看书！");
	}
}
public class test {
       public static void main(String[] args) {
    	   Student stu1=new Student();
    	   Student stu2=new Student();
           stu1.name="张三";
    	   stu1.read();
           stu2.name="李四";
    	   stu2.read();
    } 
}

访问控制权限

①．private 私有访问权限。只能在本类中访问
②．default默认访问权限，可以被本包中的其他类访问
③．protected受保护的访问权限，可以被本包以及不同包的子类访问
④．public 公共访问权限

封装性

封装是指将类得实现细节包装、隐藏起来的方法。类的封装是指将对象状态信息隐藏在对象内部，不允许外部程序直接访问对象的内部信息，而是通过该类提供的方法实现对内部信息的访问。

	private int age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name=name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		if(age<0) {
			System.out.println("您输入的年龄有误");
		}else {
			this.age=age;
		}
	}
	//定义read方法
	void read() {
		System.out.println("大家好，我是:"+name+",年龄是："+age);}
}
public class test {
    public static void main(String[] args) {
    	Student stu1=new Student();//创建学生对象
    	stu1.setName("张三");
    	stu1.setAge(-18);//为对象age属性赋值
    	stu1.read();
    } 
}

构造方法

条件:1.构造方法的名称必须与类名一致
2.构造方法名称前不能有任何返回值类型
3.不能在构造方法中使用return返回一个值但可以单独写return语句作为方法的结束。

class Student{
	private String name;
	private int age;
	public Student(String name,int age) {
		this.name=name;
		this.age=age;
		System.out.println("调用了有参构造方法");
	}
	public Student() {
		System.out.println("调用了无参构造方法");
	}
	//定义read方法
	void read() {
		System.out.println("大家好，我是:"+name+",年龄是："+age);}
}
public class test {
    public static void main(String[] args) {
    	Student stu=new Student("张三",18);//创建学生对象
    	stu.read();
    } 
}

构造方法重载（两次写）

 示例

class Student{
	private String name;
	private int age;
	public Student(String name) {
		this.name=name;
		System.out.println("调用了一个参数的构造方法");
	}
	public Student(String name,int age) {
		this.name=name;
		this.age=age;
		System.out.println("调用了两个参数的构造方法");
	}
	//定义read方法
	void read() {
		System.out.println("大家好，我是:"+name+",年龄是："+age);}
}
public class test {
    public static void main(String[] args) {
    	Student stu1=new Student("张三");//创建学生对象
    	Student stu2=new Student("张三",18);
    	stu1.read();
    	stu2.read();
    } 
}

this关键字

 分类：

调用本类中的属性

public Student(String name,int age) {
		this.name=name;
		this.age=age;
	}

调用成员方法

class Student{
	public void open() {}
	public void read() {
		this.open();
	}
}

调用构造方法

public Student() {
        this(“张三”);
		System.out.println("调用了有参的构造方法");
	}

代码块

普通代码块

public class test {
    public static void main(String[] args) {
    	{
    		int age=18;
    		System.out.println("这是普通代码块.age:"+age);
    	}
    	int age=30;
    	System.out.println("age:"+age);
    } 
}

构造块

class Student{
	String name;
	{
		System.out.println("我是构造快");//与构造方法同级
	}
	//构造方法
	public Student() {
		System.out.println("我是Student类的构造方法");
	}
}
public class test {
    public static void main(String[] args) {
    	Student stu1=new Student();
    	Student stu2=new Student();
    } 
}

注：构造块先于构造方法

static关键字

static关键字用于修饰类的成员，使得他们具备一些特殊性。

静态属性
访问格式：类名.属性名
两例对比

这两个图片对比说明static声明的属性是所有对象共享的。

注：static不能修饰局部变量
2.静态方法
访问格式：类名.方法/示例对象名.方法

3.静态代码块

{
    		System.out.println("我是构造代码块");
    	}
    	static{
    		System.out.println("我是静态代码块");
    	}

继承

 在Java中，类的继承是指在一个现有类的基础上构建一个新的类，构建的新的类被称作子类，现有的类称作父类。子类会自动继承父类的属性和方法，使得子类具有父类的特征和行为。

语法格式（用到extends关键字）

class 父类{
}
class 子类 extends 父类{
}

子类可以继承父类的属性和方法，也可以定义自己的属性和方法。并且子类不是都能访问父类的所有属性和方法，只能访问父类中用public和protected修饰的属性和方法。

注：①.Java中类只支持单继承
②.多个类可以继承一个父类
③.Java可以多层继承，即一个类的父类可以再继承另外的父类。
④.Java中子类与父类是相对的，一个类可以是某个类的子类，也可以是另一个类的父类。

方法的重写（方法）

在继承关系中，子类会自动继承父类中定义的方法,但有时在子类中需要对继承的方法进行一些修改，即对父类的方法进行重写。在子类中重写的方法需要和父类中被重写的方法具有相同的方法名参数列表以及返回值类型。

在这里插入图片描述

注：子类重写父类方法时，子类不能使用比父类的方法更严格的访问权限。

supe参数

使用super关键字可以再子类访问父类的非私有方法，非私有方法、非私有属性以及构造方法。

使用super关键字访问父类的非私有属性或调用父类的非私有方法
格式：super.属性/super.方法（参数1，参数2）
示例：

2.使用super关键字访问父类中指定的构造方法
格式：super（参数1，参数2）
在这里插入图片描述

this和super调用的构造方法代码都要求放在构造方法的首行。

区别点	super	this
访问属性	直接访问父类中的非私有属性	访问本类中的属性，如果本类中没有该属性，则从父类中继续查找
调用方法	直接调用父类中的非私有方法	调用本类中的方法，如果本类中没有该方法，则从父类继续查找
调用构造方法	调用父类改造方法，必须放在子类方法的首行	调用本类构造方法，必须放在构造方法的首行

final关键字

final关键字修饰的类不能有子类
final修饰得方法不能被子类重写、
final修饰得变量是常量，不可被修改
final可以修饰类、方法、变量

1.修饰类
~~错误代码示例：~~

final class Animal{
	String name;
}
class Dog extends Animal{
	
}
public class test {
	public static void main(String[] args) {
		Dog dog=new Dog();
	}
}

final修饰animal说明她不可被任何子类继承
2.修饰方法
~~错误示例：~~

class Animal{
	public final void shout() {}
}
class Dog extends Animal{
	public void shout() {
		
	}
}
public class test {
	public static void main(String[] args) {
		Dog dog=new Dog();
	}
}

3.修饰变量
final修饰得变量所有的必须大写，如果一个变量被public static final声明，则此变量为全局变量。
~~错误示例：~~

public class test {
	public static void main(String[] args) {
		final int AGE=18;
		AGE=20;
	}
}