Java基础语法笔记

目录

面向对象

参数传递

基本数据类型会使用值传递的方式，引用类型会使用引用传递。但是不能在函数内直接修改传入对象，因为会产生新的对象。

构造方法

class MyClass{
	int x;
	MyClass(int x){
		this.x = 5;
	}
}

继承

子类直接获取父类的成员属性和方法，java不支持多继承，子类只能继承一个父类。

// 区分父类和子类的属性可以使用super和this来区分

class FatherClass{
	int x = 1;
	
}

class MyClass extends FatherClass{
	int x = 2;
	MyClass(int x){
		System.out.println(super.x);
		System.out.println(this.x);
	}
}

new子类对象时先调用父类的构造方法，然后调用子类的构造方法。

// 父类自定义了构造方法，子类需要显式调用super来调用父类构造方法。

class FatherClass{
	int x;
	FatherClass(int x){
		int x = 1;
	}
}

class MyClass extends FatherClass{
	int x;
	MyClass(){
		super(4);
		this.x = 2;
	}
}

多态

一个对象在不同场景下表现出来的不同状态和形态

方法重载

方法重载不能通过修改返回值类型重载，只能通过参数数量和类型重载。

class MyClass{
	int x;
	MyClass(int a){
		this.x = a;
	}
	MyClass(float a){
		this.x = (int)a;
	}
}

方法重写

子类可以重写父类的方法。

@Override //@Override是伪代码，用于让编译器检查该方法是否在父类中存在
void test(){
	System.out.println("hello");
}

Java访问权限

Java类成员中的四种访问权限分别是 ：private、default、protected、public

Java类成员默认访问控制权限是default_在java语言中,类成员的默认访问属性是csdn-CSDN博客
Java 访问权限控制：你真的了解 protected 关键字吗？_java protected-CSDN博客

范围 private default protected public
同一类 √ √ √ √
同一包中的类 √ √ √
不同包的子类 √ √
其他包中的类 √

Java内部类

// main
OuterClass outer = new OuterClass();
OuterClass.InnerClass = outer.new InnerClass()

//definite
class OuterClass{
	public class InnerClass{
	}
}

Java单例模式

class SingletonObject{
	private static SingletonObject spo = null;
	
	private SingletonObject{
	}
	
	public static SingletonObject getInstance(){
		if(this.spo!=null){
			return this.spo;
		}else{
			return new SingletonObject()
		}
	}
}

//main
SingletonObject so =SingletonObject.getInstancd();

final关键字

  1. final关键字修饰变量需要显式初始化，不能通过jvm赋默认值
  2. final修饰的方法不能被子类重写
  3. final修饰的类无法被继承
  4. final不可以修饰构造方法
  5. final可以修饰方法参数，修饰的参数无法被修改
  6. 抽象类和抽象方法不能使用final修饰

抽象

无法准确地定义类和方法，可以把类和方法的一些特征抽象出来。

抽象类

抽象类无法被实例化。

抽象方法

只有声明没有实现的方法就是抽象方法，用abstract修饰

abstract class AbstractObject{
	public abstract void test();
}

抽象类不一定有抽象方法，有抽象方法的类一定是抽象类。
继承抽象类要重写抽象类的抽象方法。

接口

interface MyInterface{
	public void test();
}

枚举

enum Color 
{ 
    RED, GREEN, BLUE; 
} 
  
public class Test 
{ 
    // 执行输出结果
    public static void main(String[] args) 
    { 
        Color c1 = Color.RED; 
        System.out.println(c1); 
    } 
}

//输出
//RED

迭代枚举元素

enum Color 
{ 
    RED, GREEN, BLUE; 
} 
public class MyClass { 
  public static void main(String[] args) { 
    for (Color myVar : Color.values()) {
      System.out.println(myVar);
    }
  } 
}

匿名类

class Polygon {
   public void display() {
      System.out.println("在 Polygon 类内部");
   }
}

class AnonymousDemo {
   public void createClass() {

      // 创建的匿名类继承了 Polygon 类
      Polygon p1 = new Polygon() {
         public void display() {
            System.out.println("在匿名类内部。");
         }
      };
      p1.display();
   }
}

class Main {
   public static void main(String[] args) {
       AnonymousDemo an = new AnonymousDemo();
       an.createClass();
   }
}

常用类和对象

Object

Object类的一些方法，可以由子类重写

方法名称 功能
toString() 返回字符串，默认打印内存地址
hashCode() 返回int类型的内存地址
equals() 判断两个对象是否相等,默认比较内存地址
getClass() Class<?> class_ = obj.getClass();获取对象的类信息

数组

// 数组创建方法
Object[] obj = new Object[3]; //必须在创建数组时指定数组大小

数组的大小可以通过arr.length属性取得

数组初始化

String[] strArr = {"aaa","bbb","ccc"};
int[] intArr = {1,2,3};

String

String类是java.lang.String,java.lang下的类可以不通过显式引用来引入。

String str1 = "aaa";
String str2 = "aaa"; 
String str3 = new String("aaa");//str1,str2,str3在一个内存地址

System.out.println(str1.hashCode());  
System.out.println(str2.hashCode());  
System.out.println(str3.hashCode());

/* 输出
96321
96321
96321
*/

拼接字符串

可以通过用加号或者concat方法拼接两个字符串

String str1 = "aaa";  
String str2 = "bbb";  
System.out.println(str1+str2);  
System.out.println(str1.concat(str2));

/* 输出
aaabbb
aaabbb
*/

字符串截断

String str1 = "abcde";  
String s = str1.substring(0,2);  //参数是起始索引和终止索引，包括起始索引，但是不包括终止索引
System.out.println(s);
System.out.println(str1);//substring不改变原始字符串
/* 输出
ab
abcde
*/

String[] strArr = str1.split("c");  
for(String sItem:strArr){  
    System.out.println(sItem);  
}
/* 输出
ab
de
*/

StringBuilder

StringBuilder s = new StringBuilder();
s.append("abc")
// 更高效的字符串拼接方法，同时提供了更多的字符串操作

包装类

基本数据类型 包装类
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean

时间类

  • java.util.Data
  • Calendear

[[java pieces#^00bc98|java日期和日历类，以及如何获取当前时间戳]]

异常

有Exception和RuntimeException两大类，第一类Exception是编译期异常，第二类异常RuntimeException是运行时异常

//捕获异常语法
try{

}catch (){

}catch (){

}finally{

}

自定义异常

可以继承RuntimeException或者Exception异常类来自定义异常，继承Exception类必须显式地在可能抛出异常的方法定义中标注抛出的异常。

class MyException extends Exception{
	public MyException(String message){
		super(message);
	}
}
class MyRuntimeException extends RuntimeException{
	public MyException(String message){
		super(message);
	}
}

集合与数据结构

  • 列表
    列表有ArrayList和LinkedList两种。
    ArrayList
    • 是动态数组，可以改变大小
    • 优点：高效的随机访问和快速尾部插入
    • 缺点：中间插入和删除慢
      LinkedList：
    • 特点：双向链表，元素之间通过指针链接
    • 优点：插入和删除元素高效，迭代器性能好。
    • 缺点：随机访问相对较慢
List<String> arrayList = new ArrayList<>();
List<Integer> linkedList = new LinkedList<>();

  • 集合
    用于存储不重复的元素，常用的的有HashSet和TreeSet
    HashSet:

    • 无序集合，基于HashMap实现
    • 优点：高效的查找和插入
    • 缺点：不保证顺序
      TreeSet：
    • 特点：TreeSet是有序集合，底层基于红黑树实现，不允许重复元素
    • 优点：提供自动排序功能
    • 缺点：性能较差，不允许插入null元素

  • 映射
    HashMap：

    • 特点：基于哈希表实现的键值对存储结构
    • 优点：高效的查找插入和删除
    • 缺点：无序
      TreeMap：
    • 特点：基于红黑树实现
    • 优点：有序，支持按照键顺序遍历
    • 缺点：插入和删除相对较慢

  • 栈

  • 队列

  • 堆

PriorityQueue<Integer> minHeap = new PriorityQueue<>();
PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Collections.reverseOrder());
  • 树
class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) { val = x; }
}
  • 图
    java没有图类

![[2243690-9cd9c896e0d512ed.gif]]

IO

线程

线程状态

Java线程的6种状态及切换CSDN博客
![[Pasted image 20240323165707.jpg]]

java创建线程可以通过继承Thread类或者实现Runnable接口，然后重写run方法。

线程池

ExecutorService executorService = ExecutorService.newFixedThreadPool();

反射

posted @ 2024-03-28 14:11  黑鹿kuka  阅读(12)  评论(0)  编辑  收藏  举报