JAVA基础知识汇总

最新推荐文章于 2024-05-31 10:46:10 发布

萝卜阿咕咕

最新推荐文章于 2024-05-31 10:46:10 发布

阅读量528

点赞数 1

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

本文链接：https://blog.csdn.net/weixin_42352733/article/details/120054593

版权

Java基础专栏收录该内容

28 篇文章 3 订阅

订阅专栏

JAVA基本数据类型

整数类型：byte，1字节，8位，最大存储数据量是255，存放的数据范围是-128~127之间。-2的7次方到2的7次方减1

整数类型：short，2字节，16位，最大数据存储量是65536，数据范围是-32768~32767之间。-2的15次方到2的15次方减1

整数类型：int，4字节，32位，最大数据存储容量是2的32次方减1，数据范围是负的2的31次方到正的2的31次方减1。

整数类型：long，8字节，64位，最大数据存储容量是2的64次方减1，数据范围为负的2的63次方到正的2的63次方减1。-2的63次方到2的63次方减1

浮点类型：float，4字节，32位，数据范围在3.4e-45~1.4e38，直接赋值时必须在数字后加上f或F。3.402823e+38～1.401298e-45（e+38 表示乘以10的38次方，而e-45 表示乘以10的负45次方）

浮点类型：double，8字节，64位，数据范围在4.9e-324~1.8e308，赋值时可以加d或D也可以不加。

字符型：char，2字节，16位，存储Unicode码，用单引号赋值。

布尔型：boolean，只有true和false两个取值

一个Byte（字节）等于8个bit（位）,bit是最小的单位，1B（字节）=8bit（位）。
一般情况下，一个汉字是两个字节，英文与数字是一个字节。

Java基本数据类型封装器类图

基本数据类型进行引用时，需要用他们的封装类进行调用方法

	public static void main(String[] args) {
		Integer a = 22;
		a.byteValue()
	}

String不是基本数据类型，引用类型，这个一定要记住

String

在java中string是引用类型，本事是一个类，在java中，可以直接用“...”表示字符串，来进行创建对象。可以直接使用s1.方法，调用的是string下的各种方法

String s1 = "Hello!";
例如：
 Scanner sc = new Scanner（）；
这两个可以看成用法是一样的，都是new一个新对象，只是string的用法相对比较特殊一些

toString方法：

· 字符串本身就是字符串，返回本身：直接输出s1这个字符串；以下两种写法都是可以输出这个字符串；

非String进行toString方法调用，则输出对应的地址

equals方法：

System.out.println(s1.toString());
System.out.println(s1);

JAVA中的修饰：

public、private、protected

JAVA三大特性：

封装

继承

多态

一、方法定义

修饰符 返回值类型 方法名 （参数类型 参数名）{
    。。。。
   方法体
   。。。。
   return 返回值；

}

修饰符：修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型

①： public 返回值类型方法名（参数类型参数名）{}

未加static 的方法使用时，需新new一个对象，通过对象进行调用方法

②：public static 返回值类型方法名（参数类型参数名）{}

可以直接通过类调用，无需new对象

返回值类型：出参

①：方法可能会返回值：通过需要返回值的类型，进行定义；比如：int、string、boolon

②：方法可能没有返回值，这个时候类型定义为：void：就是无需返回任何一个值

方法名：自行定义的方法的实际名字；方法名和参数表共同构成方法签名

参数类型：（入参）参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或

变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参

数。

方法体：定义该方法功能的代码串

静态方法：被static修饰的方法为静态方法，在不同的类下，需要new一个对象才可以被调用

public static void class(){
    }

在静态方法中调用本类的其他方法或属性时，被调用的方法或属性也必须为静态的
调用非静态属性或方法必须先实例化一个对象，调用对象的方法与属性
静态方法与属性是属于类的，不用new对象

static关键字是静态的意思，可以修饰成员方法，成员变量

static修饰特点：

public class Demo2 {
		public String name;
		public int age;
		public static String university;//每个人都是在同一个学校，则这个学校可以用private修饰
		public void show() {
			System.out.println(name+"，"+age+"，"+university);
		}
}

public class Demo {
	public static void main(String[] args) {
		Student st = new Student();
		st.setName("xiaom");
		st.setAge(5);
		System.out.println(st.getName() + "," + st.getAge());
		Demo2 de = new Demo2();
		Demo2.university = "djkdjk";
		de.age = 12;
		de.name = "xiaom";
		de.show();
		Demo2 de2 = new Demo2();
		de2.age = 13;
		de2.name = "x333aom";
		de2.show();

	}
}

1、被类的所有对象共享

这也是我们判断是否使用静态关键字的条件；（比如一堆人，有一个东西共享的话，就可以把这个共享的东西直接static，让所有对象都直接被共享，不用单独一个个赋值；）

2、static访问特点：

非静态成员方法是可以访问所有静态与非静态的

静态成员方法是只可以访问静态的方法

二、方法的调用

在同一个类下面：

1、非静态方法：非静态方法就是没有 static 修饰的方法，对于非静态方法的调用，是通过对象来调用的，表现形式如下

对象名.方法（）

首先要先new一个对象，然后通过对象去进行调用

2、调用静态方法

静态方法就是用 static 修饰的方法，静态方法的调用是通过类名来调用的，表现形式如下：

类名.方法（）

public class CmjUtil {
  public  int add(int a,int b) {
    System.out.println("add方法被调用");
    return a+b;
  }
  public static void print() {
    CmjUtil cmj2 = new CmjUtil();
    int d =cmj2.add(2, 3);
    //add(1, 2);
    //int c = add(5, 4);
    System.out.println("方法调用"+d);
  }

在不同类下方的话，需要先将这个类导入该类的包，先impor，然后再进行new对象，通过对象名调用这个类的各种方法，比如这边的nextInt方法

import java.util.Scanner; //先导入这个类
public class Fish {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);//new一个对象
		System.out.println("qingshuru");
		int num = sc.nextInt();//通过对象来调用
		System.out.println("mun" + num);
	}
}

通过值传递参数：

调用一个方法的时候需要提供参数，必须按照参数列表制定的顺序提供

方法的重载：

在一个类中，我们可以定义多个方法，有一系列方法，他们功能都是类似，但是他们的参数不同时，可以把这一组方法做成同名的方法，成为方法重载‘；

注意：方法重载的返回值类型通常都是相同的

含有相同方法名的方法，但是他们的入参类型、参数值、及数量可能不一致，调用方法时，通过调用的传入的参数进行判断，调用的是哪一个方法；

如果他们传入的数据类型一样，但是变量名不一样，就不能构成方法重载，因为系统无法识别你传入的这个数据是调用那个方法

所以构成方法重载，必须是数据类型不一样、参数值及他们的数量不一致，返回值类型通常都是相同的，才能算的上是方法重载

方法的重写：

继承中，当子继承父类的所有属性与方法时，子类需要对父类中的某一个方法重新定义时，（父类中的方法不能满足子类要求的时候），就要对这个方法进行重写，当代码执行时，只会执行子类改方法，不会执行到父类的同名方法（因为那个方法已经被重新写了）

变量作用域：

变量的范围是程序中该变量可以被引用的部分。

方法内定义的变量被称为局部变量，必须声明才可以使用；方法的参数范围涵盖整个方法。参数实际上是一个局部变量

java中的get()和set（）：

为了保证数据的安全性，我们会把数据定义为private等（私有、封装），如果有需要调用，则会用到set()方法与get方法或者构造函数方法；

封装：private私有化成员属性，提供公开public的getter/setter(eclipse可通过右键，Source中可以自动生成对应属性的get和set方法

Setter:赋值（设置值的大小） Getter:取值（获取值），在哪儿用：在构造方法中初始化属性值的用！！！！！或者对象名.set/get()进行使用！！！

三、三目表达式：

可以进行求最大值

a>b?a:b

理解：a跟b进行比较，当a大于b时，输出a，反之输出b

可以用来求最大值

标志位的标准用法

在代码中，为了识别一个状态情况，会用标志位进行标志，当标志改变的时候，他可能会有对应的一个情况出现；标志位可随意进行赋值判断，主要看自己怎么赋值

例如：

package com.cmj.test;

import java.util.Scanner;

public class Login {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String userName = "admin";
		String password = "123456";
		
		boolean flag = false;
		for (int i = 1; i < 4; i++) {
			Scanner sc = new Scanner(System.in);
			System.out.println("请输入用户名");
			String name=sc.nextLine();
			System.out.println("请输入密码");
			String pass=sc.nextLine();
			if (name.equals(userName)&&pass.equals(password)) {
				flag=true;
				System.out.println("登入成功");
				break;
			}else {
				System.out.println("用户名密码错误");
			}
		}
		if(!flag) {
			System.out.println("输入错误次数超过");
		}
		
		
		
	}

}

例如：这边要求用户输入账号密码，并且错误次数不能超过3次，超过3次的话，就提示用户；

这边我们用一个标志位flag=false，在用户输入到正确密码与账号的时候，标志位进行改变，通过识别标志位是否改变，来判断用户是否账号密码成功；在for循环结束后，标志位都未改变，那就说明，用户从始至终都没有登入成功，也就是他把对应的输入次数用完，那就需要返回对应的说明；

四、类：

类的定义：

类是现实世界当中是不存在的，是一个模版，是一个概念，是抽象出来的结果。

类代表了一类事物，具有同种属性的对象称为类，是个抽象的概念，

一个类主要描述的是：状态和动作。

比如student类，他们的属性有：身高、体重、名字、电话。。。。

他们的行为（方法）：吃饭、上课、玩游戏。。。。

而其中的某一个学生A就是一个对象

[修饰符列表] class 类名｛

 属性：

 方法：

｝

对象：

对象是实际存在的个体，是现实世界当中实际存在的任何事务，有自己独特的特性。（通过不同的属性及方法构成一个特定的对象）可以认为是一张数据表中，一条一条特定的数据

属性：

定义在类中的属性，一般使用private修饰，变为私有化；这样子起到保护的作用

类中的私有的属性通过get（）和set（）方法进行获取，

private关键字：

是一个权限修饰符（私有化，把不愿意或者不需要展示出去的属性与方法用这个关键字进行修饰，就可避免被解读到）

可以修饰成员（成员变量与成员方法）

作用是保护成员不被别的类使用，被private修饰的成员只在本类中才能访问

针对private修饰的成员变量，如果需要被其他类使用，需要提供相应的操作、

①、提供“get变量名（）”方法，用于获取成员变量的值，方法用public修饰，才可被访问到

②、提供“set变量名（）”方法，用于设置成员变量的值，方法使用public修饰

成员方法：定义在类下的方法

（一个成员方法可以有参数，这个参数可以是对象也可以是基本数据类型的变量，同时成员方法有返回值和不返回值的选择，如果方法需要返回值可以在方法体中使用return 关键字，使用这个关键字后，方法的执行将被终止。

Java中的成员方法无返回值可以使用void关键字表示。）

public void class（参数类型 参数名）{
        ...//方法体

      return 返回值
    }

成员变量：定义在类下的变量，作用于整个类，与main方法还有其他方法同级

局部变量：在方法下的变量，只作用于方法中（写在方法中的变量）

成员变量 vs 局部变量
* 1.相同点：①变量的声明：数据类型变量名 = 初始化值；
* ②都有其作用域，仅在作用域内有效
* 2.不同点：
* ①在类中声明的位置不同
* >属性:直接定义在类的内部的变量
* >局部变量:方法内定义的；方法的形参；代码块内部；构造器内部；。。。
* ②成员变量声明的数据类型前可以指明这个变量的权限：private 缺省 protected public
* 局部变量声明的数据类型前不可以有权限的声明。
* ③成员变量可以不显式的赋值，那么就会使用其默认赋值。
* byte short int long==>0
* boolean==>false
* float double==>0.0
* char ==>\u0000 空格
* 引用数据类型 ==>null
* 局部变量：除方法的形参之外，都需要显式的赋值，否则报错
* 方法的形参是在方法调用的时候赋值的。
* ④在内存中保存的位置不同：
* 成员变量保存于堆空间；
* 局部变量保存于栈空间
*
*
* 总结：①变量按照数据类型分： 1.基本数据类型(byte short int long boolean float double char)
* 2.引用数据类型（类、数组、接口）
* ②变量按照声明的位置：1.成员变量(属性:直接定义在类的内部的变量) 2.局部变量(方法内定义的；方法的形参；代码块内部；构造器内部；。。。)
————————————————
版权声明：本文为CSDN博主「apphzg」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/apphzg/article/details/79433826

this关键字：

通过this关键字可以明确访问一个类的成员变量，解决成员变量与局部变量名称相同导致的冲突问题

用法：

当一个类中，定义了成员变量name、age，而在这个类下，创建了构造方法也定义了name跟age这些局部变量；他们两个的变量名是一致的；如果正常下使用name的话，是访问局部变量中的name；那如果是想要访问到成员变量，则需要通过this.name进行访问

package Cmj.Student;

public class Student {
  private String name;
  private String tel;
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
  public String getTel() {
    return tel;
  }
  public void setTel(String tel) {
    this.tel = tel;
  }
  @Override
  public String toString() {
    return "Student [name=" + name + ", tel=" + tel + "]";
  }
  
}

this的内存原理：

方法被哪个对象调用，哪个方法中的this的值就是的这个方法就是那个对象的值

JAVA中的堆和栈

基本数据类型、局部变量都是存放在栈内存中的，用完就消失。
new创建的实例化对象及数组，是存放在堆内存中的，用完之后靠垃圾回收机制不定期自动消除。

栈：

函数中定义的基本类型变量，对象的引用变量都在函数的栈内存中分配。
栈内存特点，数数据一执行完毕，变量会立即释放，节约内存空间。
栈内存中的数据，没有默认初始化值，需要手动设置。

堆：

堆内存用来存放new创建的对象和数组。
堆内存中所有的实体都有内存地址值。如果将这个地址进行赋值给另外的一个变量，后续修改里面值时，对应之前的实体也会相应改变
堆内存中的实体是用来封装数据的，这些数据都有默认初始化值。
堆内存中的实体不再被指向时，JVM启动垃圾回收机制，自动清除，这也是JAVA优于C++的表现之一（C++中需要程序员手动清除）。

封装与继承之间的异同点：

继承就是可以从多个类中，抽取公共的属性跟方法，放在一个父类中

这个跟封装有点像，封装是把公共的一些后面可以复用的代码，抽取到一个方法内

然后封装的话，只暴露其他人关心的public入口方法，通过private隐藏细节，子类可以去继承父类中暴露出来的public入口方法

继承：

Java使用extends关键字来实现继承：

例如

person类

class Person {
    private String name;
    private int age;

    public String getName() {...}
    public void setName(String name) {...}
    public int getAge() {...}
    public void setAge(int age) {...}
}

student类

class Student {
    private String name;
    private int age;
    private int score;

    public String getName() {...}
    public void setName(String name) {...}
    public int getAge() {...}
    public void setAge(int age) {...}
    public int getScore() { … }
    public void setScore(int score) { … }
}

我们会发现，student中包含了person所有属性及方法，只是多出了一个score属性，其实这个时候就可以通过继承来进行，就可以避免写太多的内容：

class Person {
    private String name;
    private int age;

    public String getName() {...}
    public void setName(String name) {...}
    public int getAge() {...}
    public void setAge(int age) {...}
}

class Student extends Person {
    // 不要重复name和age字段/方法,
    // 只需要定义新增score字段/方法:
    private int score;

    public int getScore() { … }
    public void setScore(int score) { … }
}

student的代码通过继承就可以写的相对简练

protected

但是我们会发现，父类中的属性都是使用private修饰，这会导致，子类无法访问到被private修饰的属性与方法，这边的话，student类就无法访问到person类中的name跟age字段

所以为了防止这一类问题产生，为了让子类可以访问到父类的这些字段，需要将之前private修饰的属性，改为protected修饰后就可以被子类访问；

protected关键字可以把字段和方法的访问权限控制在继承树内部，一个protected字段和方法可以被其子类，以及子类的子类所访问

继承树

我们在定义Person的时候，没有写extends。在Java中，没有明确写extends的类，编译器会自动加上extends Object。所以，任何类，除了Object，都会继承自某个类。

Java只允许一个class继承自一个类，因此，一个类有且仅有一个父类。只有Object特殊，它没有父类。

super关键字

萝卜阿咕咕

关注

1
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
JAVA基础知识汇总

一、方法的调用在同一个类下面：1、非静态方法：非静态方法就是没有 static 修饰的方法，对于非静态方法的调用，是通过对象来调用的，表现形式如下对象名.方法（）首先要先new一个对象，然后通过对象去进行调用2、调用静态方法静态方法就是用 static 修饰的方法，静态方法的调用是通过类名来调用的，表现形式如下：类名.方法（）public class CmjUtil { public int add(int a,int b) { System.out.pr
复制链接

扫一扫