Java学习中的一些注意事项_java注意事项-优快云博客

本文链接：https://blog.youkuaiyun.com/xiaodingzi127/article/details/106971424

本文详细介绍了Java编程的基础概念，包括常量、变量、数据类型及其转换，重点讲解了隐式转换与显示转换的规则。此外，还探讨了方法的重载与重写，强调了子类调用父类构造方法的机制。文章进一步阐述了super和this关键字的使用，以及继承的注意事项，如单继承、多级继承和抽象类。接口作为Java的重要特性，包括默认方法、静态方法和私有方法的引入，以及多态的概念和实现。最后，文章提到了方法的访问修饰符和运算符，以及循环和数组的基本操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

0.常量与变量

常量：不变的量
变量：

数据类型
- 基本数据类型：整型，浮点型，字符型，布尔型
- 引用类型：除基本类型以外的类型，String，类，数组，接口等
- 整型分为：字节型byte，短整型short，整型int，长整型long，其中int为默认整型
- 浮点型：float，double，其中double为浮点默认类型

long类型记得后面加L，float类型后面加F

在这里插入图片描述

1. 隐式转换与显示转换

byte，short，char --> int ->long ->float -> double
byte+short 都会转为int 运算 int a = (byte)3+(short)4
按照从小到大的类型表达范围运算的
显示转换只需加上（int)3.5
关于+=注意点，这里内部进行的转换成int再强转为short，相当于short s = （short）（s+2）

public static void main(String[] args){   
	short s = 1;   
	s+=1;   
	System.out.println(s); 
}

2.重写与重载

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

方法重载：Overload，同一个类中，多个同名函数，函数名相同，参数不同
覆盖重写：Override，子类继承父类后，在子类中重写父类中的方法，函数名相同，参数相同

注解：@Override，写在子类中的重写方法前，检测重写是否正确

重写注意

子类方法的返回值必须小于等于父类方法的返回值范围 Object>String
子类方法的权限必须大于等于父类方法的权限修饰符 public>protected>(default)>private

3. 子类一定会调用父类的构造方法（super()😉

只有子类的构造方法才能调用父类的构造方法 super()

//父类
public class Fu{
	public Fu(){
		System.out.println("父类无参构造方法");
	}
	public Fu(int num){
		System.out.println("父类有参构造方法");
	}
}
//子类，在main函数中实例化一个子对象，会自动执行super();即执行父类的构造方法
public class Zi extends Fu{
	public Zi(){
		super();//不写也会默认存在这个
		// super(10); //只能用一个super
		System.out.println("子类无参构造方法");
	}
}

4.super, this关键字的用法

super ：访问父类内容的

在子类的成员方法中访问父类的成员变量
在子类的成员方法中访问父类的成员方法
在子类的构造方法中访问父类的构造方法

public class Fu{
	int num = 20;
	public void method(){
	}
}
public class Zi extends Fu{
	int num = 20;
	public Zi(){
		super();//必须是构造方法的第一个语句且唯一一个，
	}
	 //对父类的method方法在子类中进行了覆盖重写Override，再调用原先父类中的method方法
	public void method(){
		super.method();
		System.out.println(super.num );
	}
}

this：访问本类内容的

在本类的成员方法中，访问本类的成员变量
在本类的成员方法中，访问本类的另一个成员方法
在本类的构造方法中，访问本类的另一个构造方法

public class Zi extends Fu{
	int num = 20;
	public Zi(){
		this(123);//必须是构造方法的第一个语句且唯一一个，this
	}
	public Zi(int num){
		
	}
	public Zi(int num,int m){
		
	}
	public void showNum(){
		int num = 10;
		System.out.println(this.num);//本类中的成员变量20
		System.out.println(super.num);//父类中的成员变量	
		this.methodA;
	}
	public void methodA(){
	}
}

5.继承注意事项

Java是单继承的，一个类直接父类只有一个
Java可以多级继承，爷爷，父亲，儿子

6.抽象类

如果父类中的方法不确定如何进行方法实现，那就是一个抽象方法
抽象方法所在的类必须是抽象类，在class之前加上abstract就行

public abstract class Animal{
	public abstract void eat();
}
public class Cat extends Animal{
	public void eat(){
		System.out.println("猫吃鱼"):
	}
}

抽象类抽象方法的使用

不能直接创建new抽象类对象
必须用一个子类继承抽象父类
必须覆盖重写抽象父类中所有的抽象方法（去掉abstract，补上方法体和大括号）
在主函数中创建子类对象

7.接口

概述：接口是java中的一种引用类型，是方法的集合，如果说类的内部封装了成员变量、构造方法、成员方法，那么接口内部主要就是封装了方法，包含抽象方法、默认方法和静态方法、私有方法。

接口就是一种公共的规定标准

public interface inDer{
	public abstract void eat();
	public void run();
	private void jump();
	public static void fly();
}

接口可以包含的内容
java7

常量
抽象方法

java8额外包含

默认方法
静态方法

java9额外包含

私有方法

抽象方法

接口不能直接使用，必须有一个实现类来实现该接口,格式为public class 实现类名称 implements 接口名称{}
接口的实现类必须覆盖重写接口中所有的抽象方法
创建实现类的对象，进行使用
如果实现类并没有覆盖重写接口中所有的抽象方法，那么这个实现类自己就必须是抽象类

package pickgog.interfacePackage;


//可省略抽象方法
public interface MyinterfaceAbstract {
    public abstract void methodAbs();
    public void method1();
    abstract void method2();
    void method3();
}
//----------------------------------------------
package pickgog.interfacePackage;


public class MyinterfaceAbstractImpl implements MyinterfaceAbstract {

    @Override
    public void methodAbs() {
        System.out.println("first method");
    }

    @Override
    public void method1() {
        System.out.println("second method");
    }

    @Override
    public void method2() {
        System.out.println("third method");
    }

    @Override
    public void method3() {
        System.out.println("fourth method");
    }
}
//----------------------------------------------
package pickgog.interfacePackage;

public class DemoMain {
    public static void main(String[] args) {
        MyinterfaceAbstractImpl impl = new MyinterfaceAbstractImpl();
        impl.method1();
    }
}

默认方法
public default 返回值类型方法名称（参数列表）{ 方法体 }

解决接口升级的问题
labmda表达式时会用到

//刚开始的接口
package pickgog.interfacePackage;

/**
 * Created by  on 2020/6/27.
 */
public interface MyinterfaceDefault {
    public abstract void methodAbs();
}

//实现
package pickgog.interfacePackage;

/**
 * Created by  on 2020/6/27.
 */
public class MyinterfaceDefaultimpl implements MyinterfaceDefault {

    @Override
    public void methodAbs() {
        System.out.println("默认方法");
    }
}

现在对接口升级，此时实现接口的方法就会报错，假如很多类都实现了同一个接口，接口升级时，每个类就都要更改，很麻烦

package pickgog.interfacePackage;

/**
 * Created by  on 2020/6/27.
 */
public interface MyinterfaceDefault {
    public abstract void methodAbs();
    //新添加的方法
    public abstract void methodOne();
    //改为默认方法，就不会出错了，使用时只需要实例化对象直接调用这个函
    //数，看到吗，所以需要方法体。当然也可以在实现接口的类中进行覆盖重写
    public default void methodDefault(){
    	System.out.println("");
    }
}

在这里插入图片描述

静态方法
public static 返回值类型方法名称（参数列表）{ 方法体 }

不能通过接口实现类的对象来调用接口当中的静态方法
而是通过接口名称直接调用其中的静态方法

私有方法
需要抽取共有方法，用来解决多个默认方法直接重复代码的问题
private 返回值类型方法名称（参数列表）{方法体}

-静态私有方法解决多个静态方法之间的重复代码
private static 返回值类型方法名称（参数列表）{方法体}

public interface MyinterfacePrivateA {
	public default void methodDefault1(){
		methodCommon();
		sout(""默认方法2);
	}
	public default void methodDefault2(){
		methodCommon();
		sout(""默认方法2);
	}
	private void methodCommon(){
		System.out.println("AAA");
		System.out.println("BBB");
		System.out.println("CCC");
	}
}

8.接口中常量的定义以及public static final

public interface MyinterfaceConst{
	//这是一个常量，一旦赋值，不可修改
	public static final int NUM_OF_MY_CLASS = 10;
}

public在其他类中可以直接调用访问
static代表静态，直接用接口名称调用
final代表不可变
一个类可以同时实现多个接口
- 如果多个接口中的抽象方法重名了，只需要覆盖重写一个抽象方法即可
接口与接口之间是多继承的，类只有一个父类，接口确可以继承多个接口

9.多态

一个对象多种形态，人类-》员工，人类-》学生，一个为学生的人类，两种形态。
父类名称对象名 = new 子类名称()
Fu fu = new Zi();
Animal animal = new Cat()一只猫当成一个动物使用是没问题的。

10.java中的类修饰符、成员变量修饰符、方法修饰符

成员变量或者成员方法
在这里插入图片描述

转自曾将

类修饰符：

public（访问控制符），将一个类声明为公共类，他可以被任何对象访问，一个程序的主类必须是公共类。
abstract，将一个类声明为抽象类，没有实现的方法，需要子类提供方法实现（抽象方法）。
final，将一个类生命为最终（即非继承类），表示他不能被其他类继承。
friendly，默认的修饰符，只有在相同包中的对象才能使用这样的类。

说明：对于顶级类(外部类)来说，只有两种修饰符：public和默认(default)。因为外部类的上一单元是包，所以外部类只有两个作用域：同包，任何位置。因此，只需要两种控制权限：包控制权限和公开访问权限，也就对应两种控制修饰符：public和默认(default)。

如果类使用了private修饰符，说明是个内部类。内部类的上一级是外部类，那么对应的有四种访问控制修饰符：本类(private)，同包(default)，父子类(protected)，任何位置(public)。当一个内部类使用了private修饰后，只能在该类的外部类内部使用。

1 package xiushi;
2 
3 class Test1 {
4     
5     private  class a1{
6         //这个就是一个内部类
7     }
8 }

成员变量修饰符：

public（公共访问控制符），指定该变量为公共的，他可以被任何对象的方法访问。
private（私有访问控制符）指定该变量只允许自己的类的方法访问，其他任何类（包括子类）中的方法均不能访问。
protected（保护访问控制符）指定该变量可以别被自己的类和子类访问。在子类中可以覆盖此变量。
friendly ，在同一个包中的类可以访问，其他包中的类不能访问。
final，最终修饰符，指定此变量的值不能变。
static（静态修饰符）指定变量被所有对象共享，即所有实例都可以使用该变量。变量属于这个类。
transient（过度修饰符）指定该变量是系统保留，暂无特别作用的临时性变量。
volatile（易失修饰符）指定该变量可以同时被几个线程控制和修改。

说明：静态变量与实例变量的区别

1：在语法定义上的区别：静态变量前要加static关键字，而实例变量前则不加。

2：在程序运行时的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。

方法修饰符

public（公共控制符）
private（私有控制符）指定此方法只能有自己类等方法访问，其他的类不能访问（包括子类）
protected（保护访问控制符）指定该方法可以被它的类和子类进行访问。
final，指定该方法不能被重载。
static，指定不需要实例化就可以激活的一个方法。
synchronize，同步修饰符，在多个线程中，该修饰符用于在运行前，对他所属的方法加锁，以防止其他线程的访问，运行结束后解锁。
native，本地修饰符。指定此方法的方法体是用其他语言在程序外部编写的。

11.四类运算符

1.算术运算符 +，-，*，/，%，++，–

在这里插入图片描述

2.赋值运算符 ==，+=，-=，*=，/=，%=

在这里插入图片描述

3.比较运算符 ==，<，>，<=，>=，!=

在这里插入图片描述

4.逻辑运算符 &&，||，|

在这里插入图片描述

12 方法

# 格式
修饰符 返回值类型 方法名 （参数列表）{
	方法体
	return ;
}
public class Demo{
	public static void methodName(int a){
		 System.out.println("这是一个方法");
	}
	# 再main方法中调用
	public static void main(String[] args){
		methodName(2);
	}
}

修饰符：public static
返回值类型：void
方法名：methodName
参数列表：int a
return：返回相应类型,空不需要返回

13.循环

for( , , ){}
switch

switch(num){
	case 1: sout();
		break;
	case 2: sout();
		break;
	default:
		break;
}

while(){}
do {}while()
break;
continue;

14.数组

int[] arr = new int[3];
int[] arr = new int[3]{1, 2, 3}
int[] arr = {1, 2, 3};

15.构造方法

构造方法与类同名，且无返回值，对象的实现便调用了类方法

class Fu {   
	private int n;   
	Fu(){     
	System.out.println("Fu()");   
	}
}

class Zi extends Fu {   
	Zi(){     
	// super（），调用父类构造方法     
	super(); //默认自带    
	System.out.println("Zi（）");   
	}   
} 
public class ExtendsDemo07{   
	public static void main (String args[]){     
	Zi zi = new Zi();   
	} 
}

16.常用api

scanner
其实输入接收的都是字符串，nextInt就是先接受数字的字符串再转换为Int返回，

Scanner sc = new Scanner(System.in);
//获取数字
int num = sc.nextInt();
//获取字符串
String str = sc.next();

17.字符串

判等：定义用的String类，自然用其中的方法判等

s1.equals(s2);
s1.equalsIgnoreCase(s2)