本文介绍了Java编程的基础知识，包括HellowJava的示例，键盘输入，面向对象的类、对象、构造方法、方法重载，包的使用，继承的原理，以及多态和数组。还提到了常用类如String和StringBuffer，容器的概念，异常处理，流的概念，以及图形化用户界面的基础。
目录
5.3.1栈（Stack）是一种后进先出（LIFO，Last-In-First-Out）的数据结构。
5.3.2 队列（Queue）是一种先进先出（FIFO，First-In-First-Out）的数据结构。
第一章，Hellow Java
先用java写一句Hellow Java吧：
其中，java要求在函数外部套一层类，这个类是Java程序的基础构建块，包含了程序的属性和方法。这个类定义在文件的最顶层，它的名称必须与文件名相同，以保证加载程序时能正确找到类。
public class Main {
public static void main(String[] args) {
System.out.println("Hello Java");
}
}
- 大小写敏感：Java 是大小写敏感的，这就意味着标识符 Hello 与 hello 是不同的。
- 类名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如 MyFirstJavaClass 。
- 方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写。
- 源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记 Java 是大小写敏感的），文件名的后缀为 .java。（如果文件名和类名不相同则会导致编译错误）。
- 主方法入口：所有的 Java 程序由 public static void main(String[] args) 方法开始执行。
第二章，键盘的读取录入
java的键盘读取录入需要先导入Scanner类库
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int number = input.nextInt();
String str = input.nextLine();
}
}
第三章 面向对象
3.1，类和对象
3.1.1，类
类：具有共同特征的一系列对象的描述
对象：类的实例，是静态属性和动态方法的封装体
public class Student{
private String name;
private String no;
public Student(String name, String no) {
this.name = name;
this.no = no;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getNo() {
return no;
}
public void setNo(String no) {
this.no = no;
}
}3.1.2对象：
对象和类的关系：
类是对象的定义，对象是类的实例。
生成对象：
通过对象变量（引用）使用对象
区分对象变量和对象本身，对象变量使用前需要初始化，判断其是不是指向一个对象
public void main(String[] args) {
String name = "TOM";
String no = "2021111";
Student st = new Student(name,no);
}内存分配问题：
一个方法在运行时（引用）都会建立自己的内存栈，在方法内定义的变量会逐个放入这个栈内存中。
在程序中创建一个对象（new（））时，该对象被保存在运行时的数据区（堆内存），以便反复利用。
Java对象生命周期：
创建，使用，清理。Java中，JRE会负责回收不再使用的内存，被称为垃圾回收机制（GC）
3.1.3构造方法&&this指针
构造方法：用于初始化对象。
特点：不能指定返回值。
public Student()
{
name = "TOM";
no = "00000";
}
public Student(String name, String no) {
this.name = name;
this.no = no;
}#当没有提供构造方法时，Java会在构造对象时引用Java中自带的默认构造方法。
this引用：
在类的方法中，使用this引用代表使用该方法的对象的引用。如，this、.name代表是的创建的引用中的name，而this.name = name，表示将传入的形参name赋值给引用中的name。
public Student(String name, String no) {
this.name = name;
this.no = no;
}3.1.4方法重载&&静态成员与方法
方法的重载：
当多个方法具有相同的名字（返回值也要同类型）但是有不同的参数时，产生重载。
在调用时根据参数的不同加以区分。
public void introduce(String name)
{
System.out.println("My name is" + name);
}
public void introduce(int age)
{
System.out.println("My age is" + age);
}静态数据成员和静态方法：
静态数据成员和静态方法是所有对象共享的，通过任意对象均可以访问静态成员。
class Student{
private String name;
private String no;
private static String school = "RuiXi学院";
public Student(String name, String no) {
this.name = name;
this.no = no;
}
public static String getSchool()
{
return school;
}
}应用实例：
1.可用用来统计对象的个数。
2.用来设定所有对象的同一量。
访问方法：
1.可以通过类的对象进行访问。
2.可以通过类直接访问。
3.1.5对象变量的传递
对象变量的传递：
1.基本数据类型的传递：值传递（传递的是值的拷贝）。
int i = 24;
int j;
j = i + 10;
2.引用类型：按照引用（值）传递，两个引用对象指向的是同一个堆区域。
public void main(String[] args) {
Student st1 = new Student("TOM","20211111");
Student st2 = st1;
}3.2，包（package)
功能：将类聚集起，方便组织积极的代码，同其他来源的代码分割开来。
3.2.1包的命名原则
域名：cise.sdkd.net.cn
包名：cn.net.sdkd.cise
3.2.2声明类所属包
格式：package pkg1.[pkg2.[pkg3......]]
在源程序中，只能有一个包名，可以有多个类名。
包名放在源文件的顶部（除注释外的第一句）。
包编译后的class文件存放在与完整包名匹配的子目录里。
注意
编译时不需要检查包路径的正确性。
class文件必须放到相应的目录下。
执行时要写类的全称（控制台方法）。
3.2.3使用包中的类
类可以直接使用其所在包的所有的类。
import Rui.Student;
public class Main {
public static void main(String[] args) {
System.out.println("Hello world!");
Student st = new Student();
System.out.println(st.toString());
}
}3.3，继承
3.3.1 什么是继承？
继承是一种保持对象差异性同时共享对象的相似性的复用
基类（父类、超类），派生类（子类）
关键字：extends
class Student {
private String name;
private int no;
private boolean sex;
}
class CollegeStudent extends Student {
private String major;
}通过继承，子类自动拥有父类所有的普通成员成员（成员变量和方法）。
3.3.2 类成员的可访问性
| 关键字 | 同一个类中 | 同一个包中 | 派生类中 | 其他包中 |
| public | √ | √ | √ | √ |
| protected | √ | √ | √ | |
| 无访问修饰符 （default） | √ | √ | ||
| private | √ |
3.3.3 方法重写、super与final
方法重写：
在子类中对继承来的方法进行重新编写，以满足子类对于相同方法的使用。
重写方法的要求：
必须与被重写方法具有相同的名称，参数列表。
子类方法的返回值类型比父类方法的返回值类型更小或相等。
子类方法生命抛出的异常类要比父类党法生命抛出的异常类更小火相等。
子类方法的访问权限不能小于被重写方法的访问权限。
class Student {
private String name;
private int no;
private boolean sex;
public void show()
{
System.out.println("My name is "+name+" ,my no is"+ no);
}
public String getName() {
return name;
}
public int getNo() {
return no;
}
}
class CollegeStudent extends Student {
private String major;
public void show()
{
System.out.println("My name is "+getName()+" ,my no is"+ getName()+" ,my major is "+major);
}
}
super的作用：
指向自己父类对象的一个引用，这个父类ishi离自己最近的一个父类。
1.使用super引用父类的成员和方法。
2.调用父类的构造方法。
final：
使得被final修饰的变量变为常量，final的成员变量被初始化后就不能被修改。
final形参，不能修改形参的值。
final引用，不能修改引用本身，但是可以修改被引用的地址空间中存储的数据。
final类，阻止该类被继承。
final方法，组织该方法被重写。
3.3.4 子类的构造方法
对于构造方法，父类的构造方法不能被子类继承。
在子类的构造方法中必须调用父类的构造方法。
调用方式：通过super关键字进行调用：
class Student {
private String name;
private int no;
private boolean sex;
public Student(String name, int no, boolean sex) {
this.name = name;
this.no = no;
this.sex = sex;
}
}
class CollegeStudent extends Student {
private String major;
public CollegeStudent(String name, int no, boolean sex, String major){
super(name, no, sex);
this.major = major;
}
}3.3.5 对象转型
is-a关系，对于每一个子类对象，“is-a”父类相对象。
class Pet {
public String name;
public Pet(String name){
this.name = name;
}
}
class Dog extends Pet{
public String furcolor;
public Dog(String name,String furcolor) {
super(name);
this.furcolor = furcolor;
}
}对象转型是子类类型和父类类型的转换。
向上转型：父类引用类型指向了子类的实例对象
向下转型：通过引用类型强转，恢复了子类的成员变量以及方法。
instanceof：判断改引用所指向的对象是否属于该类或者该类的子类。
public static void show(Pet a){
System.out.println("name:"+a.name);
if (a instanceof Cat){
Cat cat = (Cat)a;
System.out.println(cat.eyescolor+"eyescolor");
} else if (a instanceof Dog) {
Dog dog = (Dog)a;
System.out.println(dog.furcolor+"furcolor");
}
}使用一个方法处理多个的子类对象，实现了一定的可扩展性。
3.3.6 Object类
Object类是所有类的根类。
在与String类型数据做“+”操作时，自动调用该对象所属类的toString方法。
toString方法：将类的属性通过字符串的类型进行返回。
equals方法：在Object基类中，使用equals方法和==比较是相同的，但是在实际使用过程中，我们会需要根据各自类的特点进行比较，此时就需要重写equals方法。
在重写equals方法时一定要注意分清方法的重写和重载。
class Student{
String name;
int no;
//equals方法的重写
@Override
public boolean equals(Object obj) {
if(obj instanceof Student) {
Student st = (Student) obj;
return name == st.name && no == st.no ;
}
else return false;
}
}class Student{
String name;
int no;
//equals方法的重载
public boolean equals(Student st) {
return name == st.name && no == st.no ;
}
}3.3.7 Java API文档 与 代码注释
3.4，多态
3.4.1 多态的定义
Java中的多态是指 同样的消息被不同类型的对象接收时产生的不同的行为。
方法绑定（Binding）：方法调用和方法生命之间的联系。
静态方法绑定（方法重载）：编译时编译器就能准确地判断应该调用哪个方法。
动态方法绑定（方法重写）：运行时判断所引用的对象的实际类型，根据实际类型调用 相应的方法。
3.4.2 抽象类和抽象方法
抽象类不需要实例，抽象方法也不需要实现；抽象类和抽象方法的作用在于对与所有的子类所共有的方法进行整合；
abstract关键字：
抽象方法需要使用abstract关键字进行修饰，含有抽象方法的类必须使用abstract修饰符修饰为抽象类。
abstract class Shape {
public abstract double calculateArea();
public abstract double calculatePerimeter();
}
class Circle extends Shape {
private double radius;
public Circle(double radius) {
this.radius = radius;
}
@Override
public double calculateArea() {
return Math.PI * radius * radius;
}
@Override
public double calculatePerimeter() {
return 2 * Math.PI * radius;
}
}
class Rectangle extends Shape {
private double length;
private double width;
public Rectangle(double length, double width) {
this.length = length;
this.width = width;
}
@Override
public double calculateArea() {
return length * width;
}
@Override
public double calculatePerimeter() {
return 2 * (length + width);
}
}
java中没有多继承，但是一个类可以实现多个接口
3.5，数组
3.5.1数组的创建和初始化
创建数组：new 数组元素类型[ 元素个数 ]
int []s = new int[2];
s[0] = 2;
s[1] = 5;数组常用的方法：
import java.util.Arrays;
class Main{
public static void main(String[] args) {
int []a = { 3,5,1,2,4};
int len = a.length;
//len = 5
Arrays.sort(a);
//{1,2,3,4,5}
}
}数组的大小：在数组创建后，数组的大小是不能改变的
3.5.2 二维数组
String[][] s = new String[2][];
s[0] = new String[2];
s[1] = new String[3];
s[0][0] = new String("Good");
s[0][1] = new String("Luck");
s[1][0] = new String("to");
s[1][1] = new String("you");
s[1][2] = new String("!");3.5.3 数组的拷贝
3.6，接口
3.6.1 接口的定义与实现
接口是函数、类的方法；定义多个类共同的行为规范。
/*[修饰符] interface 接口名[extends 父接口1,父接口2·····]{
类型 常量成员名 = 值;
·····
返回类型 方法名(参数列表);
·····
}*/
public interface PCI{
void start();
void stop();
}
public class MyDevice implements PCI {
// 实现接口中的方法
@Override
public void start() {
// 这里是开始设备的具体实现逻辑
System.out.println("设备已经启动");
}
@Override
public void stop() {
// 这里是停止设备的具体实现逻辑
System.out.println("设备已经停止");
}
// 可以在这个类中定义其他方法和属性
// 示例的主方法
public static void main(String[] args) {
MyDevice device = new MyDevice();
device.start(); // 调用start()方法启动设备
device.stop(); // 调用stop()方法停止设备
}
}3.6.2 接口应用实例
package Rui;
public class Student implements Comparable{
private String name;
private int no;
private int age;
static private String school;
public Student() {
this.name = "no name";
this.no = -1;
this.age = -1;
}
public Student(String name, int no, int age) {
this.name = name;
this.no = no;
this.age = age;
}
public String getName() {
return name;
}
@Override
public String toString() {
return "My name is "+name+" my no is "+ no +" my age is "+age+", I am from "+school;
}
@Override
public int compareTo(Object o) {
Student st = (Student) o;
if (this.no > st.no){
return 1;
} else if (this.no < st.no) {
return -1;
}
else {
return 0;
}
}
}
import Rui.Student;
import java.util.Arrays;
class Main{
public static void main(String[] args) {
Student []students = new Student[3];
students[0] = new Student("Tom",1,18);
students[1] = new Student("Su",3,17);
students[2] = new Student("Jack",2,19);
Arrays.sort(students);
for (int i = 0;i < students.length;i++)
{
System.out.println(students[i].getName());
}
}
}第四章 常用类
4.1String类
String类是一个不可变的字符序列 其类的内部是 peivate final char value[];
String s = "Hello";
s = s + "World";
//此时s由指向“Hello” 变成指向 “HelloWorld”
String s1 = "Monday";
String s2 = "monday";
String s3 = new String("Monday");
//s1 == s2 s1 != s3;
4.2 StringBuffer
是Unicode字符的可变序列，是一种线程安全的可变字符序列。
StringBuffer buffer = new StringBuffer("How are you!");
buffer.append('?').append("\n").append("fine!");
Sring str = buffer.toString();
第五章 容器
5.1 容器的概念与框架
容器是一种用于存储和组织对象的数据结构。它允许我们以不同的方式管理和操作对象集合。
容器的作用：
1.存放对象。
2.特定方式获取对象，操作对象。
3.对象的插入删除，自动完成容量的变化。
列表（List）：按照一定的次序（对象进入的顺序）排列的对象集，对象之间有一定的次序关系，
对象可以重复。
集合（Set）：对象唯一，不会重复；元素没有顺序。
队列（Queue）：根据排队规则确定对象的顺序。先进先出原则。
映射表（Map）：一群成对的对象集，这些对象各自保持着" 键---值 " （key-value）的对应关系
5.2 Collection&&List
5.2.1Collection接口的基本方法
1.添加元素：
add(element)； //将指定的元素添加到集合中。
addAll(collection)； //将指定集合中的所有元素添加到当前集合中。
2.删除元素：
remove(element)； //从集合中删除指定的元素。
removeAll(collection)； //从集合中删除与指定集合中包含的元素相匹配的所有元素。
clear()； //从集合中删除所有元素，使集合变为空。3.查询元素：
contains(element); //判断集合是否包含指定元素。
containsAll(collection); //判断集合是否包含指定集合中的所有元素。
isEmpty(); //检查集合是否为空。
size(); //获取集合中元素的数量。4.访问元素：
iterator(); //获取集合的迭代器，用于遍历集合中的元素。
toArray(); //将集合中的元素转换为数组。5.2.2 LinkedList 和 ArrayList
ArrayList：使用动态数组实现的List，支持快速随机访问和修改。LinkedList：使用双向链表实现的List，支持高效的插入和删除操作。
5.2.3 泛型
List<String> list = new LinkedList<String>();
//表示只接受String类型的5.3 栈与队列
5.3.1栈（Stack）是一种后进先出（LIFO，Last-In-First-Out）的数据结构。
主要方法：
public Object push(E item);
//将元素item压栈，即将元素添加到栈顶。
public Object pop();
//弹栈操作，将栈顶的元素弹出，并从栈中移除该元素。
public Object peek();
//查看栈顶的元素，但不对栈进行修改操作。
public boolean empty();
//判断栈是否为空。
public int search(Object o);
//搜索元素o在栈中的位置，返回对应的索引值。5.3.2 队列（Queue）是一种先进先出（FIFO，First-In-First-Out）的数据结构。
主要方法
offer(E element);
//将指定的元素element添加到队列中。如果队列容量已满，offer()方法会返回false；否则，它将返回true。
peek();
//查看队列的头部元素，但不进行移除操作。
poll();
//移除队列中的头部元素，并返回被移除的元素。
isEmpty();
//用于检查队列是否为空。5.3.3 声明定义
Stack<Integer> stack = new Stack<>();
Queue<Integer> queue = new LinkedList<>();5.4 集合Set
一种特殊的Collection，特点是元素无顺序，不重复。
5.4.1 HashSet：
基于哈希表实现的Set，提供快速的插入、删除和查找操作。不保证元素的顺序。
5.4.2 TreeSet：
基于红黑树实现的Set，元素按照自然排序或指定的比较器进行有序存储。
HashSet<String> hashSet = new HashSet<>();
TreeSet<Integer> treeSet = new TreeSet<>();
Collection<String> c = new TreeSet<>();
Collection<String> c = new HashSet<>();
5.5 字典Map
Map接口表示一种键值对的映射关系。它提供了存储和访问键值对的方法，其中每个键对应唯一的值。
5.5.1 Map的特点：
- 键值对：Map中的元素是以键值对（key-value pair）的形式存储的，每个键都唯一。
- 无序：Map中的元素没有固定的顺序，不按照插入顺序或键的自然顺序进行排序。具体的实现类可以有不同的遍历顺序。
- 可以包含null键和null值：Map允许键和值为null，但是通常建议保持键的唯一性，因为如果多个键映射到同一个值，可能会导致不确定性。
5.5.2 常用的Map实现类有：
1.HashMap：基于哈希表实现的Map，它提供了快速的插入、删除和查找操作。不保证元素的顺序。
Object put(key,value);
//将指定的键值对存储到TreeMap中。
Object get(Object key);
根据指定的键获取对应的值。如果键不存在，则返回null。
Object remove(Object key);
//根据指定的键从TreeMap中删除对应的键值对，并返回被删除的值。
boolean cotainKey(Object key);
//判断TreeMap中是否包含指定的键。
boolean cotainValue(Object value);
//判断TreeMap中是否包含指定的值。
int size();
//返回TreeMap中键值对的数量。
boolean isEmpty();
//检查Map是否为空，即是否不含任何键值对。
void putAll(Map m);
//将指定Map中的所有键值对拷贝到当前的TreeMap中。
void clear();
//清空Map，即移除所有的键值对。
2.TreeMap：基于红黑树实现的有序Map，元素按照键的自然顺序或指定的比较器进行排序。
put(key, value);
//将指定的键值对存储到TreeMap中。
get(key);
//根据指定的键获取对应的值。如果键不存在，则返回null。
remove(key);
//根据指定的键从TreeMap中删除对应的键值对，并返回被删除的值。
containsKey(key);
//判断TreeMap中是否包含指定的键。
containsValue(value);
//判断TreeMap中是否包含指定的值。
size();
//返回TreeMap中键值对的数量。
isEmpty();
//检查TreeMap是否为空，即是否不含任何键值对。
putAll(map);
//将指定Map中的所有键值对拷贝到当前的TreeMap中。
clear();
//清空TreeMap，即移除所有的键值对。3.LinkedHashMap：基于哈希表和链表的结合体实现的Map，元素按照插入顺序或访问顺序进行排序。
5.6 迭代器
作用：以统一的方式对各种集合元素进行遍历，迭代。
实现Collection接口的容器类都有一个iterator方法，返回一个实现了Interator接口的对象。
Iterator中的方法：
boolean hasnext();
//检查迭代器中是否还有下一个元素。
object next();
//返回迭代器中的下一个元素，并将迭代器的状态移动到下一个元素的位置。
void remove();
//移除迭代器返回的上一个元素。通常，它只能在调用 next() 方法之后立即调用一次，而且每次调用 remove() 之后，只能调用一次。
扫一扫
25万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
