Java学习（期末复习）

Y-leq

已于 2024-09-17 20:30:52 修改

阅读量874

点赞数 26

文章标签： java 学习开发语言

于 2024-09-07 01:45:53 首次发布

本文链接：https://blog.csdn.net/weixin_74128253/article/details/141978826

版权

基本概念

命名规范

所有标识符都应该以字母、$(美元符)、_(下划线) 开头

首字母之后可以是字母、$、_ 或数字任何字符组合

关键字不能作为变量名或方法名

字节：

1B（byte）=8 bit 1024B=1KB

主要特性：

简单性面对对象可移植性高性能分布式多态性多线程安全性健壮性

逻辑运算符：

逻辑运算符	含义	说明
&&	与	两个都为1，结果为1
\|\|	或	两个都为0，结果为0
^	异或	两个都相异为1
!	取反	0变1，1变0
<<	左移	高位丢弃，低位补0
>>	右移

%和/的区别

在这里插入图片描述

包机制：

 import java.util.;          //通配符* 导入包下所有的类

输入：

Import java.utils.Scanner
Scanner scanner = new Scanner(System.in);
	while (scanner.hasNext()){	       
    	System.out.println("scanner.nextInt()="+scanner.nextInt());
    }
	Scanner.close();

随机生成字母：

Random random = new Random();
	char c = (char) (random.nextInt(26) + 65);
	System.out.println("c = " + c);

语句：

switch 多选择结构

char grade = 'C'; 
switch (grade){
    case 'A':
        System.out.println("优秀");
        break; //可选，跳出当前结构
    ……
    default: //默认，以上值没匹配到
        System.out.println("不及格");
        break;
}

while循环

int i=0;
int sum=0;
while(i<100){ //计算1+2+3+...+100
    i++;
    sum+=i;
}
System.out.println(sum); //5050

do…while循环

//先执行后判断，至少执行一次
do{
    i++;
    sum+=i;
}while(i<100) //跟上面效果一样

for循环

//（初始化;条件判断;迭代）
for(int i=0;i<100;i++){
    i++;
    sum+=i;
}

foreach遍历

int [] numbers = {10,20,30,40,50}; //定义一个数组
for (int x:numbers){         //遍历数组或集合中的元素
    System.out.println(x); //遍历数组的元素 10 20 30 40 50
}

数组的声明创建：

int[] nums=new int[3];  //int[] nums={1,2,3……} 
nums[0]=1;  //给数组元素赋值
nums[1]=2;
nums[3]=3;
for(int num:nums){  //foreach循环遍历
	System.out.printIn(num);
}

int[] arr=new int[scanner.nextInt()]; //动态创建数组 
for(int i=0;i<n;i++){
  arr[i]=sc.nextInt();
}

数组的工具类

java.util.Arrays

方法	说明
fill	给数组赋值
sort	升序
equals	比较数组中元素是否相等
binarySearch	对排序好的数组进行二分查找

Math 类的常用方法

import java.lang.Math;

方法	说明
abs（）	计算绝对值：System.out.printIn（Math.abs（num））
sqrt（）	计算方根
ceil（）	向上取整
floor（）	向下取整
round（）	计算小数进行四舍五入
max（） min（）	计算两个数的较大（小）值：System.out.printIn（Math.max(e，7)）
random（）	大于0.0小于1…0的随机值
pow（）	计算指数函数的值

面向对象的三个特征：

继承多态封装

类和对象：

package sample;
public class StringTest{
  private String s;
  public void printString(){
      System.out.println(s);
  }
  public void changeString(String str){
      s = str;
  }

  public static void main(String[] args){
      StringTest st = new StringTest();  //创建了一个StringTest类的对象st
      st.changeString("Hello SZTU");
      st.printString();
  } 
}

继承关系和构造方法调用

继承：继承是一种机制，允许一个类（子类或派生类）继承另一个类（父类或基类）的属性和方法。子类可以继承父类的特性，然后根据需要进行扩展、覆盖或重写。

注：Java中不支持类之间的多重继承，即不允许一个子类继承多个父类。

class Animal {
	void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    void makeSound() {
        super.makeSound(); // 调用父类的makeSound 方
        System.out.println("Dog barks");
    }
}

public class Test {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        myDog.makeSound();
    }
}

super：可以在子类中调用父类的方法

继承特性和方法重写

package sample;
class Employee             //基类
{
    public String name; //名字
    public int salary;  //薪水
    public static String getSalary(String name, int salary) {
        String str;
        str = "名字: " + name + "  Salary: " + salary;
        return str;
    }
    public static String getSalary2(String name, int salary) {
        String str;
    	str = "名字: " + name + "  Salary: " + salary;
    	return str;
	}
}

public class TestExtend extends Employee  //子类 {
    public static void main(String[] args) {
    //覆盖了从 Employee 类继承的同名方法
    	System.out.println("覆盖的方法调用：" + getSalary("王一",500));
    	System.out.println("继承的方法调用：" + getSalary2("王一",500));
    	System.out.println("覆盖的方法调用：" + getSalary("王飞",10000));
    	System.out.println(“继承的方法调用：” + getSalary2(“王飞",10000));
    }
    public static String getSalary(String name, int salary) {
        String str;
        if (salary>5000)
            str = "名字: " + name + "  Salary: " + salary;
        else
            str = "名字: " + name + "  Salary:** **低于5000";
        return str;
    }
};

Employee 类是一个基类，包括了名字（name）和薪水（salary）的属性，以及两个静态方法 getSalary 和 getSalary2，用于返回员工的信息。
TestExtend 类是 Employee 类的子类，它继承了 Employee 类的属性和方法。

在 TestExtend 类中，定义了一个名为 getSalary 的新静态方法，它覆盖了从 Employee 类继承的同名方法，而 getSalary2 方法没有被覆盖。

在main方法中

getSalary(“王一”, 500) 调用的是 TestExtend 类中的 getSalary 方法，因为它覆盖了 Employee 类的同名方法。根据薪水的大小，它返回相应的员工信息。

getSalary2(“王一”, 500) 调用的是 Employee 类中的 getSalary2 方法，因为它没有被覆盖。它返回员工信息。

类的封装特性

class EncapTest {
  int a; // 默认存取控制（default access）
  public int b; //公有存取控制（public access）
  private int c; //私有存取控制（private access）
//setc 和 getc，用于设定和获取私有变量 c 的值
  // 访问c的方法
  void setc(int i) {//设定c的值
   c = i;
  }
  int getc() { //获得c的值
   return c;
  }
}

public class AccessTest {
  public static void main(String args[]) {
   EncapTest ob = new EncapTest();
   // 以下代码是正确的
   ob.a = 10;
   ob.b = 20;
   // 以下代码会产生错误
   // ob.c = 30; 无法访问封装对象
   // 我们必须通过公有的方法操作c
   ob.setc(30); // 正确
   System.out.println("a，b，and c: " + ob.a + " " +ob.b + " " + ob.getc())
  }
}

c 具有私有存取控制，只能在 EncapTest 类内部访问，其他类无法直接访问它。

可以在 EncapTest 类内部定义两个方法：setc 和 getc，用于设定和获取私有变量 c 的值。

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

类的多态特性

多态性是指一个对象可以以不同的方式呈现，即相同的接口可以有多个不同的实现。多态性使得可以使用通用的接口来操作不同类型的对象，而无需关心具体对象的类型。多态性的实现通常涉及方法重载和方法重写，以及接口的使用

public class Test {
    public Test() {}
    public static void main(String[] args) {
        Shape[] s= {
            new Shape(1,4),
            new Rectangle(1,2,3,4),
            new Circle(2,3,5)};
        for (Shape shape : s) { //实现多态 
            shape.draw();
        }
    }
}

class Shape{  //定义一个基类（Shape）
    protected int x;
    protected int y;
    public Shape(){ }
    public Shape(int x, int y){
        this：当局部变量和成员变量同名时，可以使用 this 关键字来引用成员变量，以区分局部变量和成员变量
        this.x = x;
        this.y = y;
    }
    public void draw(){ System.out.println("This is a test in Shape."+x+y);
  }
}

//创建派生类，继承基类（Rectangle和Circle）
class Rectangle extends Shape{
    private int heigth;
    private int weight;
    public Rectangle(int x, int y, int w, int h){
        super(x,y);
        this.weight = w;
        this.heigth = h;
    }
  public void draw(){ System.out.println("This is a test in Rectangle.+x+y+weight+heigth");}
}

class Circle extends Shape{
    private int r;
    public Circle(int x, int y, int r){
        super(x,y);
        this.r = r;
    } 
    public void draw(){System.out.println("This is a test in Circle."+x+y+r);}
}

语法

实例变量和静态变量

静态变量是在所有对象实例之间共享的，因此无论使用哪个对象实例来访问静态变量，它们都会访问到相同的静态变量。

实例变量是每个对象实例独有的，所以不同对象实例的实例变量可以有不同的值。

class Example05_1 {
    int a = 1;
    static int b = 2;   b为静态变量
}

class Test {
    public static void main(String args[]) {
        System.out.println("b=" + Example05_1.b);
        Example05_1.b*= 2;  b=4
        Example05_1 o1 = new Example05_1 ();
        o1.a = 10;
        System.out.println("o1.a="+ o1.a);  a=10
        System.out.println("b="+ o1.b);   
    Example05_1 o2=new Example05_1 ();
    System.out.println("o2.a=" + o2.a);
    System.out.println("b="+ o2.b);
    }
}

静态变量（b）通过类名（Example05_1.b）来访问，而实例变量（a）通过对象实例（o1.a和o2.a）来访问。

Integer与int的区别：

Integer的初始值是null

int的初始值是0

Integer存储在堆内存

int类型是直接存储在栈空间

Integer是对象类型，它封装了很多的方法和属性，我们在使用的时候更加灵活。

自动装箱和拆箱

装箱：将基本数据类型,封装成包装类型的对象,这个过程就是装箱

Integer in=new Integer()

拆箱：从包装类型的对象中,将其包装的基本类型的数据取出,这个过程就是拆箱

Int i=in.intValue();

自动装箱：可以直接使用基本类型的数据,给引用类型的变量赋值

Integer A=3;

自动拆箱：可以直接使用包装类对象,给基本类型的变量赋值

Int a=A;

Java中有哪些基本数据类型以及其对应的包装类？

byte：Byte

short：Short

int：Integer

long：Long

float：Float

double：Double

char：Character

boolean：Boolean
在这里插入图片描述

枚举

用enum关键字来声明枚举，然后就可以直接定义枚举值

enum Day {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

public class EnumTest {
    public static void main(String[] args) {
        // 创建枚举数组
        Day[] days = new Day[] { Day.MONDAY, Day.TUESDAY, Day.WEDNESDAY,
        Day.THURSDAY, Day.FRIDAY, Day.SATURDAY, Day.SUNDAY };
        // 打印枚举常量的序号以及枚举值
        for (int i = 0; i < days.length; i++) {
            System.out.println("day[" + days[i].ordinal() + "]:"+ days[i].name());
        }
        // 通过compareTo方法比较,实际上其内部是通过ordinal()值比较的
       System.out.println("day[1] VS day[2]:" + days[1].compareTo(days[2]));
    }
}

枚举类的常量具有哪些方法？

name()：返回枚举常量的名称。

ordinal()：返回枚举常量的序号，从0开始计数。

compareTo()：比较枚举常量的顺序，返回值为负表示当前枚举常量在参数枚举常量之前，返回值为正表示在其后，返回值为0表示相等。

values()：返回一个包含所有枚举常量的数组。

注释和注解

1. 注释：

来给代码添加说明和解释的文本，它对程序的编译和执行没有任何影响

2. 注解：

注解可以用来声明、配置和使用，可以对类、方法、字段等进行注解。注解可以在运行时被读取和处理，可以通过反射机制获取注解信息。通常使用@Override和@Deprecated注解，

@Override: 表示正确的覆盖操作。

@Deprecated: 表示不建议使用的操作;

@SuppressWarnings：压制警告

@Override

public void someMethod() {
  // 重写父类的方法
}

@Deprecated

public void oldMethod() {
  // 这个方法已经被弃用
}

函数式接口

Lambda表达式

形参列表：指定Lambda表达式的参数列表。可以包含零个或多个参数，并用括号括起来。

例如：(a, b) -> {…}

箭头符号：由->组成，用于将参数列表与Lambda表达式的主体分隔开。

Lambda表达式的主体：包含具体的执行逻辑。可以是一个表达式或一段代码块。

例如：a + b或{ System.out.println(“Hello”); }

interface Drawable{ 
    public void draw(); 
} 

public class Hello {
    public static void main(String[] args) {
        int width = 10;
        // with lambda expression
        Drawable d = () -> {
            System.out.println("Drawing " + width);
        };
        d.draw();
    }
}

字符串的截取和定位

在 Java 中，字符串的截取和定位可以通过使用 substring() 方法和 indexOf() 方法来实现。

substring() 方法：用于从原始字符串中截取子串。它有两个重载的形式：

substring(int beginIndex): 从指定的 beginIndex 开始截取到字符串的末尾。

substring(int beginIndex, int endIndex): 从指定的 beginIndex 开始截取到 endIndex - 1 处的字符。**

class SubStringExample{
 public static void main(String[] args)   {
        String s="hello Java语言";
        int n1=s.indexOf('a');
        int n2=s.indexOf("a语");
        System.out.println("n1="+n1+" n2="+n2);
        char c=s.charAt(2);
        String s1=s.substring(6,10);
        String s2=s.substring(4,7);
        System.out.println("c="+c+" s1="+s1+" s2="+s2);
 }
}

使用String类的public String concat(String str)方法可以把调用该方法的字符串与参数指定的字符串连接
在这里插入图片描述

在这里插入图片描述

抛出异常

throw关键字

throw 是一个关键字，用于手动抛出异常。当程序中发生某些不符合预期的情况时，可以使用 throw 语句显式地抛出异常对象。throw 语句通常与 try-catch 块结合使用，以便在发生异常时捕获并处理它。

throw new FileNotFoundException("File not found");

ArithmeticException ：

是 Java 中的一个运行时异常类，继承自 RuntimeException。

它通常在数学运算出现错误的情况下被抛出。最常见的情况是除法运算时除数为零，但也可能发生其他导致算术运算错误的情况。

class Test {
      static int method(int x, int y) {
          if (x < y)
              throw new ArithmeticException("x<y");
          return x - y;
      }
      public static void main(String[] args) {
          try {
              int result1 = method(5, 10); // 触发异常，因为5 < 10
		      System.out.println("Result 1: " + result1);
          } catch (ArithmeticException e) {
              System.out.println("Exception caught: " + e.getMessage());
          }
      }
}