Java笔记（大多来源于韩顺平网课P1-P396）

.Java文件 (源文件)  --编译-- .class文件(字节码文件) --运行-- 结果

什么是编译？

1.有了java源文件，通过编译器将其编译成JVM可以识别的字节码文件。
2.在该源文件目录下，通过javac编译工具对Hello.java文件进行编译。
3.如果程序没有错误，没有任何提示，但在当前目录下会出现一个Hello.class文件，
该文件称为字节码文件，也是可以执行的java的程序。

JVM：Java虚拟机（Java Virtual Machine 简称JVM）是运行所有Java程序的抽象计算机，是Java语言的运行环境，它是Java 最具吸引力的特性之一。只要根据JVM规格描述将解释器移植到特定的计算机上，就能保证经过编译的任何Java代码能够在该系统上运行。

什么是运行？

1.有了可执行的java程序(Hello.class字节码文件)
2.通过运行工具java.exe对字节码文件进行执行，本质就是.class装载到jvm机执行

java程序开发注意事项

对修改后的Hello.java源文件需要重新编译，生成新的class文件后，再进行执行，才能生效。

在 Java 项目中，src 目录通常包含源代码文件，而 out 目录通常包含编译后的类文件。

Java开发注意事项和细节说明
1.Java源文件以 .java为扩展名。源文件的基本组成部分是类（class）
2.Java应用程序的执行入口是main()方法。它有固定的书写格式：

public static void main(String[] args){..}

3.如果源文件包含一个public类，则文件名必须按该类名命名！
4.一个源文件中最多只能有一个public类。其它类的个数不限，也可以将main方法写在非
public类中，然后指定运行非public类，这样入口方法就是非public 的main方法

Java程序的入门介绍

关键字public称为访问修饰符，这些修饰符用于控制程序的其他部分对这段代码的访问级别

关键字class表明Java程序中的全部内容都包含在类中

标识符和关键字

转载Java-Java中的标识符和关键字_java类的标识-CSDN博客

常量

关键字final表示这个变量只能被赋值一次。习惯上，常量名使用全大写。

在Java中，经常希望某个常量可以在一个类中的多个方法中使用，通常将这些常量称为类常量。

可以使用关键字static final设置一个类常量。

例：public static final double CURRY = 30;

转义字符

\t:一个制表位，实现对齐的功能
System.out.println("北京\t天津\t上海")；

\n:换行符
System.out.println("jack\nsmith\nmary");

\\:一个\
System.out.println("C:\Windows\\System32\\cmd.exe");

\″ :一个“
System out println("老韩说：\"要好好学习java,有前途\"")；

\:一个‘
System.out.println("老韩说：\'要好好学习java,有前途\'")；

\r:一个回车System.out.printIn("韩顺平教育\r北京");
System.out.println("韩顺平教育\r北京")；  //北京平教育

程序中+号的使用

1.当左右两边都是数值型时，则做加法运算
2.当左右两边有一方为字符串，则做拼接运算
3.课堂测试题1min
#下面代码输出什么？

System.out.println(100+98);   //198
System.out.println("100"+ 98);  //10098

System.out.println(100 + 3 + "hello");  //103hello
System.out.println("hello" + 100 +3);   //hello1003

数据类型

整数类型

默认值是0

byte类型用于在大型数组中节约空间，主要代替整数

字节（Byte）是计算机信息技术用于计量存储容量的一种计量单位，也表示一些计算机编程语言中的数据类型和语言字符。

bit:二进制数的一位所包含的信息就是一比特，如二进制数0100就是4比特。

浮点类型

如果基本的整数和浮点数精度不能满足需求，可以使用java.math包中两个类：BigInteger和BigDecimal.这两个类可以处理包含任意长度数字序列的数值

使用静态的valueOf方法可以将普通的数值转换为大数

BigInteger a = BigInteger.valueOf(100);

不能使用人们熟悉的算术运算符处理大数，而需要使用大数类中的add和multiply方法

BigInteger c = a.add(b);
BigInteger d = c.multiply(b.add(BigInteger.valueOf(2)));
//d = c * (b + 2）

运算符

/： 7/2 = 3   //将正常结果的小数部分去掉

如果是整型数据进行除法运算,那么得到的结果就是被除数除以除数的结果,其结果必然是整型数据.

如果除不尽,会把得到的小数部分直接抹去,抹去的时候不要考虑四舍五入的规则

被除数和除数至少有一个为浮点型数据时，那么结果一定会是浮点类型的数据,计算数值的话就按照我们平常小数和整数之间的除法计算去进行计算即可。

需要注意：整数被0除将会产生一个异常，而浮点数被0除会得到无穷大或NaN结果

Java API文档

在线工具 - ioDraw

char   字符型

char c1=‘a’;    //

char c2=‘\t’;    // 会输出一个空格

char c3=‘王’;   //

char c4=‘97’;   // 会输出一个a

System.out.println(...);

char c2="a";

System.out.println ( (int) c2);   //得到97

System.out.println('a'+10);  //得到107

布尔类型

static修饰符

在Java中，`static`是一个关键字，用于修饰类的成员（字段、方法、内部类）或块。

1. 静态字段（Static Fields）：使用`static`修饰的字段属于类本身，而不是类的实例。所有该类的实例共享相同的静态字段。可以通过类名直接访问静态字段，无需创建类的实例。静态字段在内存中只有一份拷贝。

2. 静态方法（Static Methods）：使用`static`修饰的方法属于类本身，而不是类的实例。可以通过类名直接调用静态方法，无需创建类的实例。静态方法只能访问静态字段和调用其他静态方法。

3. 静态块（Static Blocks）：使用`static`修饰的代码块称为静态块。静态块在类加载时执行，用于初始化静态字段或执行其他静态操作。一个类可以有多个静态块，它们按照在类中出现的顺序依次执行。

4. 静态内部类（Static Inner Classes）：使用`static`修饰的嵌套类称为静态内部类。静态内部类与外部类的实例无关，可以直接通过外部类名访问。静态内部类可以拥有静态字段、静态方法和非静态成员。

使用`static`修饰的成员可以在没有创建类的实例的情况下访问和调用，因此它们通常用于共享数据或提供实用方法，而不依赖于特定的对象实例。

final修饰符

自动类型转换

字符串

String类的substring方法可以从一个较大的字符串提取出一个子串。

String greeting = "Hello";

String s = greeting.substring(0,3);

得到 “Hel”的字符串。

Java语言允许使用+号连接两个字符串

a = "Stephen ";
b = "Curry";
c = a + b;

 如果需要把多个字符串放在一起，用一个界定符分隔，可以使用静态join方法

String all = String.join(" / ","S","M","L","XL"); // "S / M / L / XL"

repeat方法

String repeated = "Java".repeat(3);  //  JavaJavaJava

equals方法检测两个字符串是否相等

s.equals(t) 如果字符串s与字符串t相等，则返回true；否则，返回false。

如果想检测两个字符串是否相等，而不区分大小写，可以使用equalsIgnoreCase方法

一定不要使用==运算符检测两个字符串是否相等

空串

空串""是长度为0的字符串

字符串大写字母改为小写

String toLowerCase()

字符串小写字母改为大写

String toLowerCase()

public class Main 
{  
    public static void main(String[] args) 
    {  
        String originalString = "HELLO WORLD";  
        String lowerCaseString = originalString.toLowerCase();  
  
        System.out.println("Original String: " + originalString);  
        System.out.println("Lower Case String: " + lowerCaseString);  
    }  
}

在 Java 中，要获取字符串的长度，可以使用 String 类的 length() 方法
其语法格式：字符串名.length();
返回的值是int类型的长度值。

        String str1 = "我是一个字符串";

        System.out.println("我是一个字符串".length());//7
        System.out.println(str1.length());//7

        String str2 = "我是另一个字符串";
        int str2Length1 = str2.length();
        int str2Length2 = "我是另一个字符串".length();

        System.out.println(str2Length1);//8
        System.out.println(str2Length2);//8
        

在Java笔记(大多来源于韩顺平网课P466-568)中有字符串的剩余知识点

强制类型转换

1.   .9会丢失，得到1

2.造成数据溢出，100会变成-48   //byte取值范围是-128~127

---

基本数据类型和String类型的转换

键盘输入

首先需要import java.util.*;

要想通过控制台进行输入，首先需要构造一个与“标准输入流”关联的Scanner对象

nextLine方法将读取一行输入 （在输入行中有可能包含空格）

next 读取一个单词

nextInt 读取一个整数

nextDouble 读取一个浮点数

输出

print() 直接输出，不换行

println() 每次输出后自动换行

printf() C风格的输出，实现格式化输出功能

System.out.printf();

可以使用语句System.out.println(x)将数值x输出到控制台。这条命令将以x的类型所允许的最大非0数位个数打印输出x

调用System.out.printf("%8.2f",x);会以一个字段宽度打印x，这包括8个字符，另外精度为小数点后2个字符

可以为printf提供多个参数

System.out.printf("Hello,%s.Next year,you'will be %d",name,age);
f表示浮点数，s表示字符串，d表示十进制整数

可以使用静态的String.format方法创建一个格式化的字符串，而不打印输出

String message = String.format("Hello,%s,Next year,you'will be %d",name,age);

循环

while循环语句在最前面检测循环条件。因此，循环体中的代码有可能一次都不执行。如果希望循环体至少执行一次，需要使用do/while循环将检测放在最后

增强for循环

for(int element : a)
    System.out.println(element);
//打印数组a的每一个元素，一个元素占一行

有一个更加简单的方式可以打印数组中的所有值，即利用Arrays类的toString方法，调用Arrays.toString (a),返回一个包含数组元素的字符串，这些元素包围在中括号内，并用逗号分隔。

System.out.println(Arrays.toString(a));

switch中的case穿透现象

switch中的case穿透现象，记得break-CSDN博客

数学函数

在Math类中，包含了各种各样的数学函数。

要想计算一个数值的平方根，可以使用sqrt方法

double x = 4;
double y = Math.sqrt(x);
System.out.println(y);   //prints 2.0

幂运算

double y = Math.pow(x,a);

只要加上 import static java.lang.Math.*; 就不必在数学方法名和常量名前添加前缀“Math”了。

数组

在Java中，允许有长度为0的数组，但他和null不相同

数组拷贝

数组翻转

数组扩容

简单版：

加强版：

数组排序

要想对数值型数组进行排序，可以使用Arrays类中的sort方法 从小到大

int [a] = new int[10000];
......
Arrays.sort(a);

从大到小方法 

import java.util.Arrays;
import java.util.Comparator;

public class Main
{
    public static void main(String[] args)
    {
        Integer[] numbers = {4, 2, 8, 6, 3, 5, 9, 1};

        // 使用自定义比较器进行降序排序
        Arrays.sort(numbers, (o1, o2) ->   //匿名内部类，lambda表达式
        {
            return o2 - o1; // 降序排序
        });
        //在Comparator的compare方法中，你通过返回o2 - o1来实现降序排序，
        //因为当o2大于o1时，返回值是正数，这表示o2应该在o1之后（在降序排序中）；
        //当o2小于o1时，返回值是负数，表示o2应该在o1之前；当两者相等时，
        //返回0，表示它们的顺序不变。

        // 输出排序后的数组
        System.out.println(Arrays.toString(numbers));
    }
}

 

冒泡排序

选择排序

插入排序

快速排序

归并排序

桶排序

查找

if (index == -1)
{
    System.out.println("Sorry,can not find " + findName);
}

二维数组

要想快速地打印一个二维数组的数据元素列表，可以调用

 System.out.println(Arrays.deepToString(a));

杨辉三角

二维数组注意事项

int []x, y[]" 表示定义了一个整数类型的一维数组x，以及一个整数类型的二维数组y，但这种写法很怪。

String strs[] = new string[]{"a","b","c"};  是正确的

bool类型数组在没有赋值前默认是false

随机数

1、Math.random()方法
在Math类中存在一个random()方法，用于产生随机数字，这个方法默认生成大于等于0.0小于1.0的double型随机数，即0<=Math.random()<1.0，虽然Math.random()方法只可以产生0~1之间的double型数字，其实只要在Math.random()语句上稍加处理，就可以使用这个方法产生任意范围的随机数。

公式：(数据类型)(最小值+Math.random()*(最大值-最小值+1))

public class RandomExample 
{
    public static void main(String[] args) 
    {
        int[] randomNumbers = new int[10];

        // 生成10个随机整数并存储到数组中
        for (int i = 0; i < randomNumbers.length; i++) 
        {
            randomNumbers[i] = (int) (Math.random() * 100) + 1;
        }

        // 打印随机数数组
        for (int number : randomNumbers) 
        {
            System.out.println(number);
        }
    }
}

(int) (Math.random() * 100)生成的随机数范围是0到99，然后通过+ 1操作将范围调整为1到100。

2、Random类
除了Math类中的random()方法可以获取随机数之外，在Java中还提供了一种可以获取随机数的方式，那就是java.util.Random类。可以通过实例化一个Random对象创建一个随机数生成器。

语法如下：

Random r=new Random();

其中，r是指Random对象。

在Random类中提供了获取各种数据类型随机数的方法，下面举例几个常用的方法。

public int nextInt()    返回一个随机整数。
public int nextInt(int)    返回大于等于0且小于n的随机整数。
public long nextLong()    返回一个随机长整型值。
public boolean nextBoolean()    返回一个随机布尔型值。
public float nextFloat()    返回一个随机浮点型值。
public double nextDouble()    返回一个随机双精度型值。
public double nextGaussian()    返回一个概率密度为高斯分布的双精度值。
 

import java.util.*;

public class RandomExample 
{
    public static void main(String[] args) 
    {
        // 创建一个随机数生成器对象
        Random random = new Random();

        // 生成一个随机整数
        int randomNumber = random.nextInt(); ()里写10，就是0-9的任意整数
        int randomNumber1 = random.nextInt(21) - 10;
        //random.nextInt(21)将生成一个介于0和20之间的随机整数（不包括20本身）。
        //然后，我们从生成的随机数中减去10，以使其范围变为-10到10之间。

        System.out.println("随机数：" + randomNumber);
    }
}

类与对象

在主函数中写

Person p1 = new Person();

int a = p1.getsum(10,20);

得到

0 0 1
1 1 1
1 1 3

和=5
差=-3

跨类调用方法

// 定义一个类A
class A 
{
    public void methodA() 
    {
        System.out.println("这是类A中的方法A");
    }
}

// 定义一个类B
class B 
{
    public void methodB() 
    {
        System.out.println("这是类B中的方法B");

        // 创建类A的对象并调用其方法
        A objA = new A();
        objA.methodA();
    }
}

// 主类
public class Main 
{
    public static void main(String[] args) 
    {
        // 创建类B的对象并调用其方法
        B objB = new B();
        objB.methodB();
    }
}

方法传参机制

堆与栈

转载自一文读懂堆与栈的区别_堆和栈的区别-CSDN博客

转载自【JAVA】堆、栈与方法区_堆栈方法区分别存储的内容-CSDN博客

日期时间

转载自Java——日期时间（SimpleDateFormat）-CSDN博客

重载

public class OverLoad01 
{ 
	//编写一个main方法
	public static void main(String[] args) 
    {
		MyCalculator mc = new MyCalculator();
		System.out.println(mc.calculate(1, 2));
		System.out.println(mc.calculate(1.1, 2));
		System.out.println(mc.calculate(1, 2.1));
	}
}

class MyCalculator  
{
	//下面的四个 calculate方法构成了重载

	//两个整数的和
	public int calculate(int n1, int n2)  
    {
		System.out.println("calculate(int n1, int n2) 被调用");
		return n1 + n2;
	}

	//一个整数，一个double的和
	public double calculate(int n1, double n2) 
    {
		return n1 + n2;
	}
	//一个double ,一个Int和 
	public double calculate(double n1, int n2) 
    {
		System.out.println("calculate(double n1, int n2) 被调用..");
		return n1 + n2;
	}
	//三个int的和
	public int calculate(int n1, int n2, int n3) 
    {
		return n1 + n2 + n2;
	}

}

可变参数

public class VarParameter01 
{ 
	//编写一个main方法
	public static void main(String[] args) 
    {
		HspMethod m = new HspMethod();
		System.out.println(m.sum(1, 5, 100)); //106
		System.out.println(m.sum(1,19)); //20
	}
}

class HspMethod 
{
	//可以计算 2个数的和，3个数的和 ， 4. 5， 。。
	//可以使用方法重载
	// public int sum(int n1, int n2) {//2个数的和
	// 	return n1 + n2;
	// }
	// public int sum(int n1, int n2, int n3) {//3个数的和
	// 	return n1 + n2 + n3;
	// }
	// public int sum(int n1, int n2, int n3, int n4) {//4个数的和
	// 	return n1 + n2 + n3 + n4;
	// }

	//上面的三个方法名称相同，功能相同, 参数个数不同-> 使用可变参数优化
	
	//1. int... 表示接受的是可变参数，类型是int ,即可以接收多个int(0-多) 
	//2. 使用可变参数时，可以当做数组来使用 即 nums 可以当做数组
	//3. 遍历 nums 求和即可

	public int sum(int... nums) 
        {
		//System.out.println("接收的参数个数=" + nums.length);
		int res = 0;

		for(int i = 0; i < nums.length; i++) 
        {
			res += nums[i];
		}

		return res;
	}
}

public class VarParameterDetail 
{ 
	//编写一个main方法
	public static void main(String[] args) 
    {
		//细节: 可变参数的实参可以为数组
		int[] arr = {1, 2, 3};
		T t1 = new T();
		t1.f1(arr);
	}
}

class T 
{
	public void f1(int... nums) 
    {
		System.out.println("长度=" + nums.length);
	}

	//细节: 可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后
	public void f2(String str, double... nums) 
    {

	}
	//细节: 一个形参列表中只能出现一个可变参数
	//下面的写法是错的.
	// public void f3(int... nums1, double... nums2) {}  
}

全局变量 成员变量 局部变量的区别

全局变量、成员变量和局部变量是在编程中常见的变量类型，它们有以下区别：

1. 作用域范围：
   - 全局变量：在整个程序中都可见和访问，可以在任何地方使用。
   - 成员变量：属于类的成员，可以被类的所有方法访问，其作用域限定在类的范围内。
   - 局部变量：定义在方法、代码块或者循环内部，其作用域仅限于所在的方法、代码块或循环。

2. 生命周期：
   - 全局变量：在程序启动时创建，在程序结束时销毁，其生命周期与整个程序的执行周期相同。
   - 成员变量：随着类的实例化而创建，在对象销毁时才销毁，其生命周期与对象的创建和销毁相关。
   - 局部变量：在其所在的方法、代码块或循环执行时创建，当方法、代码块或循环执行完毕后销毁，其生命周期仅限于所在的上下文环境。

3. 访问权限：
   - 全局变量：可以被程序中的任何部分访问，但需要注意全局变量的可见性和封装性。
   - 成员变量：根据其访问修饰符（public、private、protected等）来确定访问权限，可以通过对象访问。
   - 局部变量：只能在其所在的方法、代码块或循环内部访问，作用范围有限。

4. 初始化：
   - 全局变量和成员变量：如果没有显式初始化，会有默认值（例如数值类型的默认值为0，引用类型的默认值为null）。
   - 局部变量：必须在使用前进行显式初始化，否则编译器会报错。

需要注意的是，全局变量和成员变量具有较长的生命周期，因此在使用时需要注意其对内存的占用和管理。而局部变量的作用范围和生命周期较小，更灵活，但也需要注意变量的作用域和初始化。

作用域

public class VarScopeDetail { 

	//编写一个main方法
	public static void main(String[] args) {
		Person p1 = new Person();
		
		 */
		//p1.say();
		//
		T t1 = new T();
		t1.test(); //第1种跨类访问对象属性的方式

		t1.test2(p1);//第2种跨类访问对象属性的方式

	}
}

class T {

	//全局变量/属性：可以被本类使用，或其他类使用（通过对象调用)
	public void test() {
		Person p1 = new Person();
		System.out.println(p1.name);//jack
	}

	public void test2(Person p) {
		System.out.println(p.name);//jack
	}
}

class Person {
	//细节: 属性可以加修饰符(public protected private..)
	//      局部变量不能加修饰符
	public int age = 20;

	String name = "jack";

	public void say() {
		//细节 属性和局部变量可以重名，访问时遵循就近原则
		String name = "king";
		System.out.println("say() name=" + name);
	}

	public void hi() {
		String address = "北京";
		//String address = "上海";//错误,重复定义变量
		String name = "hsp";//可以
	}
}

构造方法/构造器

public class Constructor01 
{ 

	//编写一个main方法
	public static void main(String[] args) 
    {
		//当我们new 一个对象时，直接通过构造器指定名字和年龄
		Person p1 = new Person("smith", 80);
		System.out.println("p1的信息如下");
		System.out.println("p1对象name=" + p1.name);//smith
		System.out.println("p1对象age=" + p1.age);//80
	}
}

//在创建人类的对象时，就直接指定这个对象的年龄和姓名

class Person 
{
	String name;
	int age;
	//构造器
	//老韩解读
	//1. 构造器没有返回值, 也不能写void
	//2. 构造器的名称和类Person一样
	//3. (String pName, int pAge) 是构造器形参列表，规则和成员方法一样
	public Person(String pName, int pAge) 
    {
		System.out.println("构造器被调用~~ 完成对象的属性初始化");
		name = pName;
		age = pAge;
	}
}

封装

package com.hspedu.encap;

public class Encapsulation01 
{
    public static void main(String[] args) 
    {
        Person person = new Person();
        person.setName("韩顺平");
        person.setAge(30);
        person.setSalary(30000);
        System.out.println(person.info());
        System.out.println(person.getSalary());

        //如果我们自己使用构造器指定属性
        Person smith = new Person("smith", 80, 50000);
        System.out.println("====smith的信息======");
        System.out.println(smith.info());
    }
}


//不能随便查看人的年龄,工资等隐私，并对设置的年龄进行合理的验证。年龄合理就设置，否则给默认
//年龄, 必须在 1-120, 年龄， 工资不能直接查看 ， name的长度在 2-6字符 之间


class Person 
{
    public  String name; //名字公开
    private int age; //age 私有化
    private double salary; //..

    public Person() 
    {
    }
    //有三个属性的构造器
    public Person(String name, int age, double salary) 
    {
//        this.name = name;
//        this.age = age;
//        this.salary = salary;
        //我们可以将set方法写在构造器中，这样仍然可以验证
        setName(name);
        setAge(age);
        setSalary(salary);
    }

    public String getName() 
    {
        return name;
    }
    public void setName(String name) 
    {
        //加入对数据的校验,相当于增加了业务逻辑
        if(name.length() >= 2 && name.length() <=6 ) 
        {
            this.name = name;
        }else 
        {
            System.out.println("名字的长度不对，需要(2-6)个字符，默认名字");
            this.name = "无名人";
        }
    }

    public int getAge() 
    {
        return age;
    }

    public void setAge(int age) 
    {
        //判断
        if(age >= 1 && age <= 120) 
        {//如果是合理范围
            this.age = age;
        } else 
        {
            System.out.println("你设置年龄不对，需要在 (1-120), 给默认年龄18 ");
            this.age = 18;//给一个默认年龄
        }
    }

    public double getSalary() 
    {
        //可以这里增加对当前对象的权限判断
        return salary;
    }

    public void setSalary(double salary) 
    {
        this.salary = salary;
    }
    //写一个方法，返回属性信息
    public String info() 
    {
        return "信息为 name=" + name  + " age=" + age + " 薪水=" + salary;
    }
}

package com.hspedu.encap;

/**
 * 创建程序,在其中定义两个类：Account和AccountTest类体会Java的封装性。
 * Account类要求具有属性：姓名（长度为2位3位或4位）、余额(必须>20)、
 * 密码（必须是六位）, 如果不满足，则给出提示信息，并给默认值(程序员自己定)
 * 通过setXxx的方法给Account 的属性赋值。
 * 在AccountTest中测试
 */
public class Account 
{
    //为了封装，将3个属性设置为private
    private String name;
    private double balance;
    private String pwd;

    //提供两个构造器
    public Account() 
    {
    }

    public Account(String name, double balance, String pwd) 
    {
        this.setName(name);
        this.setBalance(balance);
        this.setPwd(pwd);
    }

    public String getName() 
    {
        return name;
    }

    //姓名（长度为2位3位或4位）
    public void setName(String name) 
    {
        if (name.length() >= 2 && name.length() <= 4) 
        {
            this.name = name;
        } else 
        {
            System.out.println("姓名要求（长度为2位3位或4位），默认值 无名");
            this.name = "无名";
        }
    }

    public double getBalance() 
    {
        return balance;
    }

    //余额(必须>20)
    public void setBalance(double balance) 
    {
        if (balance > 20) 
        {
            this.balance = balance;
        } else 
        {
            System.out.println("余额(必须>20) 默认为0");
        }
    }

    public String getPwd() 
    {
        return pwd;
    }

    //密码（必须是六位）
    public void setPwd(String pwd) 
    {
        if (pwd.length() == 6)  
        {
            this.pwd = pwd;
        } else 
        {
            System.out.println("密码（必须是六位）默认密码为 000000");
            this.pwd = "000000";
        }
    }
    //显示账号信息
    public void showInfo() 
    {
        //可以增加权限的校验
        System.out.println("账号信息 name=" + name + " 余额=" + balance + " 密码" + pwd);
        if() 
        {
            System.out.println("账号信息 name=" + name + " 余额=" + balance + " 密码");
        }
        else
        {
            System.out.println("你无权查看...");
        }
    }
}

继承

代码案例在  C:\Users\王源崧\IdeaProjects\P20231014\src\extend\improve_

子类继承了所有的属性和方法，但是私有属性和方法不能在子类中直接访问，要通过公共的方法去访问

代码案例同样在  C:\Users\王源崧\IdeaProjects\P20231014\src\extend\improve_

可见 extend/improve_/ExtendsDetail.java

super只能存在于构造方法中

ctrl + h 可以看到类的继承关系

加载顺序：Object,GrandPa,Father,Son

这时请大家注意，要按照查找关系来返回信息
(1) 首先看子类是否有该属性
(2) 如果子类有这个属性，并且可以访问，则返回信息
(3) 如果子类没有这个属性，就看父类有没有这个属性(如果父类有该属性，并且可以访问，就返回信息..)
(4) 如果父类没有就按照(3)的规则，继续找上级父类，直到Object...

多态(polymorphic)

多态（英语：polymorphism）指为不同数据类型的实体提供统一的接口。多态类型（英语：polymorphic type）可以将自身所支持的操作套用到其它类型的值上。

计算机程序运行时，相同的消息可能会送给多个不同的类别之对象，而系统可依据对象所属类别，引发对应类别的方法，而有不同的行为。简单来说，所谓多态意指相同的消息给予不同的对象会引发不同的动作。

程序见Idea--prc/多态

动态绑定机制

多态数组

多态参数