JAVA学习-基础部分【1】

我们使用的教程是b站官方的黑马程序员教程和网上的教程，然后从中记录。

具体网址为：
Java字符串的处理 (biancheng.net)

其他书籍下载：

1.rar_免费高速下载|百度网盘-分享无限制 (baidu.com)

第一部分首先是基础的java学习

一、基础知识

1、JAVAEE和JAVAESE两个技术平台是什么

Java SE（Java Platform，Standard Edition）

Java EE，Java 平台企业版（Java Platform Enterprise Edition）

2、如何安装java

可以到oracel官网，先行下载jdk安装。

3、java最重要的两个命令是什么

javac编译命令、java执行命令

可以在命令行中查看相应版本：

java -version
javac -version

4、简单的HelloWorld

public class HelloWorld{
	public static void main (String[] args){
		System.out.println("Hello world");
    }
}

然后在命令行中编译运行。

5、方法重载

 public static int max(int num1, int num2) {
      int result;
      if (num1 > num2){
         result = num1;
      }else{
         result = num2;
      }
      return result; 
   }

但是此max方法，只能适用于int型数据，我们需要创建另一个有相同名字但参数不同的方法。

public static double max(double num1, double num2) {
  if (num1 > num2){
    return num1;
  }else{
    return num2;
  }
}

如果调用max方法时传递的是int型参数，则 int型参数的max方法就会被调用；

如果传递的是double型参数，则double类型的max方法体会被调用，这就是方法重载；

就是说一个类的两个方法拥有相同的名字，但是有不同的参数列表。

Java编译器根据方法签名判断哪个方法应该被调用。

方法重载可以让程序更清晰易读。执行密切相关任务的方法应该使用相同的名字。

重载的方法必须拥有不同的参数列表。不能仅仅依据修饰符或者返回类型的不同来重载方法。

6、关于abstract

Java抽象（abstract）类 (biancheng.net)

7、java正则表达式验证电话号码

Java正则表达式验证电话号码 (biancheng.net)

8、java对象的销毁

Java对象的销毁 (biancheng.net)

Java 语言的内存自动回收称为垃圾回收（Garbage Collection）机制，简称 GC。垃圾回收机制是指 JVM 用于释放那些不再使用的对象所占用的内存。

注意：C++ 语言对象是通过 delete 语句手动释放。如果回收内存的任务由程序负责，也就是说必须在程序中显式地进行内存回收，这无疑会增加程序员的负担，而且存在很多弊端。Java 语言对象是由垃圾回收器收集然后释放，程序员不用关系释放的细节。

在 Java 虚拟机的堆区，每个对象都可能处于以下三种状态之一。

• 可触及状态：当一个对象被创建后，只要程序中还有引用变量引用它，那么它就始终处于可触及状态。
• 可复活状态：当程序不再有任何引用变量引用该对象时，该对象就进入可复活状态。在这个状态下，垃圾回收器会准备释放它所占用的内存，在释放之前，会调用它及其他处于可复活状态的对象的 finalize() 方法，这些 finalize() 方法有可能使该对象重新转到可触及状态。
• 不可触及状态：当 Java 虚拟机执行完所有可复活对象的 finalize() 方法后，如果这些方法都没有使该对象转到可触及状态，垃圾回收器才会真正回收它占用的内存。

9、简单样例代码（用户修改密码或用户名）

在Member.java中：

public class Member{
    private String username;
    private String password;
 
    public String getUsername(){
        return username;
    }
    public void setUsername(String username){
        this.username = username;
    }
 
    public String getPassword(){
        return password;
    }
    public void setPassword(String password){
        this.password = password;
    }
 
    public Member(String username,String password){
        this.username = username;
        this.password = password;
    }
 
    public String toString(){
        return"用户名"+username+"\n密码"+password;
        }
}

在MemberTest.java中：

import java.util.Scanner;
 
public class MemberTest{
    public static void main(String[] args){
        Member admin = new Member("admin","123456");
        Scanner input = new Scanner(System.in);
        System.out.println("输入原密码");
        String pwd = input.next();
        if(pwd.equals(admin.getPassword())){
            System.out.println("输入新密码");
            admin.setPassword(input.next());
        }
        else{
            System.out.println("密码错误");
        }
        System.out.println("----------------用户信息----------------\n"+admin);
    }
    
}

二、面向对象和封装、继承、多态

笔记内容来源于(推荐看原内容)：

Java工程师成神之路 (gitee.io)

1、面向对象的三大特征：封装继承多态

一个类就是一个封装了数据以及操作这些数据的代码的逻辑实体。

继承可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

多态就是指一个类实例的相同方法在不同情形有不同表现形式。

Java中的多态的概念比较简单，就是同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。Java中多态其实是一种运行期的状态。为了实现运行期的多态，或者说是动态绑定，需要满足三个条件：

• 有类继承或者接口实现
• 子类要重写父类的方法
• 父类的引用指向子类的对象

public class Parent{
    
    public void call(){
        sout("im Parent");
    }
}
 
public class Son extends Parent{// 1.有类继承或者接口实现
    public void call(){// 2.子类要重写父类的方法
        sout("im Son");
    }
}
 
public class Daughter extends Parent{// 1.有类继承或者接口实现
    public void call(){// 2.子类要重写父类的方法
        sout("im Daughter");
    }
}
 
public class Test{
    
    public static void main(String[] args){
        Parent p = new Son(); //3.父类的引用指向子类的对象
        Parent p1 = new Daughter(); //3.父类的引用指向子类的对象
    }
}

2、重写和重载

重载：

• 被重载的方法必须改变参数列表；
• 被重载的方法可以改变返回类型；
• 被重载的方法可以改变访问修饰符；
• 被重载的方法可以声明新的或更广的检查异常；
• 方法能够在同一个类中或者在一个子类中被重载。

重载的例子上面已经提到了，下面提一个重写的例子：

class Dog{
    public void bark(){
        System.out.println("woof ");
    }
}
class Hound extends Dog{
    public void sniff(){
        System.out.println("sniff ");
    }
 
    public void bark(){
        System.out.println("bowl");
    }
}
 
public class OverridingTest{
    public static void main(String [] args){
        Dog dog = new Hound();
        dog.bark();
    }
}

上面的例子中，我们分别在父类、子类中都定义了bark方法，并且他们都是无参方法，所以我们就说这种情况就是方法重写。即子类Hound重写了父类Gog中的bark方法。

在测试的main方法中，dog对象被定义为Dog类型。

在编译期，编译器会检查Dog类中是否有可访问的bark()方法，只要其中包含bark（）方法，那么就可以编译通过。

在运行期，Hound对象被new出来，并赋值给dog变量，这时，JVM是明确的知道dog变量指向的其实是Hound对象的引用。所以，当dog调用bark()方法的时候，就会调用Hound类中定义的bark（）方法。这就是所谓的动态多态性。

方法重写：

• 参数列表必须完全与被重写方法的相同；
• 返回类型必须完全与被重写方法的返回类型相同；
• 访问级别的限制性一定不能比被重写方法的强；
• 访问级别的限制性可以比被重写方法的弱；
• 重写方法一定不能抛出新的检查异常或比被重写的方法声明的检查异常更广泛的检查异常
• 重写的方法能够抛出更少或更有限的异常（也就是说，被重写的方法声明了异常，但重写的方法可以什么也不声明）
• 不能重写被标示为final的方法；
• 如果不能继承一个方法，则不能重写这个方法。

3、继承和实现

继承（Inheritance）：如果多个类的某个部分的功能相同，那么可以抽象出一个类出来，把他们的相同部分都放到父类里，让他们都继承这个类。

实现（Implement）：如果多个类处理的目标是一样的，但是处理的方法方式不同，那么就定义一个接口，也就是一个标准，让他们的实现这个接口，各自实现自己具体的处理方法来处理那个目标。

在Java中，继承使用extends关键字实现，而实现通过implements关键字。

那java为什么不支持多继承？

多继承就是一个类有多个父类的情况。C++中使用了虚继承来解决多重继承的问题。java中允许一个类实现多个接口，一个接口也可以继承多个父接口。由于接口只允许有方法声明而不允许有方法实现（Java 8以前），这就避免了 C++ 中多继承的歧义问题。

4、封装

封装的特点：

• 只能通过规定的方法访问数据。
• 隐藏类的实例细节，方便修改和实现。

样例代码：

Java封装图书信息类 (biancheng.net)

基本需求为：

• 基本信息包括图书名称（bookName）、总页数（pagelbtalNum），其中页数不能少于 200 页，否则输出错误信息，并赋予默认值 200。
• 为各个属性设置赋值和取值方法。
• 具有 details() 方法，该方法在控制台输出每本图书的名称和总页数。

实现封装的具体步骤如下：

1. 修改属性的可见性来限制对属性的访问，一般设为 private。
2. 为每个属性创建一对赋值（setter）方法和取值（getter）方法，一般设为 public，用于属性的读写。
3. 在赋值和取值方法中，加入属性控制语句（对属性值的合法性进行判断）。

5、关于super

由于子类不能继承父类的构造方法，因此，如果要调用父类的构造方法，可以使用 super 关键字。super 可以用来访问父类的构造方法、普通方法和属性。

super和this的区别：

this 指的是当前对象的引用，super 是当前对象的父对象的引用。

super 关键字的用法：

• super.父类属性名：调用父类中的属性
• super.父类方法名：调用父类中的方法
• super()：调用父类的无参构造方法
• super(参数)：调用父类的有参构造方法

this 关键字的用法：

• this.属性名：表示当前对象的属性
• this.方法名(参数)：表示调用当前对象的方法

6、接口

我们举个例子来说明，详细描述可见：

Java接口（Interface）的定义和实现 (biancheng.net)

需要进行两个数求和运算和比较运算功能的类很多，可以定义一个接口来将类似的功能组织在一起。

我们首先创建一个IMath的接口，接口定义使用的关键字是 interface：

public interface IMath {
    public int sum();    // 完成两个数的相加
    public int maxNum(int a,int b);    // 获取较大的数
}

接着定义一个MathClass的类，实现这个接口。实现则使用 implements 关键字。

public class MathClass implements IMath {
    private int num1;    // 第 1 个操作数
    private int num2;    // 第 2 个操作数
    public MathClass(int num1,int num2) {
        // 构造方法
        this.num1 = num1;
        this.num2 = num2;
    }
    // 实现接口中的求和方法
    public int sum() {
        return num1 + num2;
    }
    // 实现接口中的获取较大数的方法
    public int maxNum(int a,int b) {
        if(a >= b) {
            return a;
        } else {
            return b;
        }
    }
}

最后创建测试，实例化接口的实现类，调用该类中的方法并输出结果。

public class NumTest {
    public static void main(String[] args) {
        // 创建实现类的对象
        MathClass calc = new MathClass(100, 300);
        System.out.println("100 和 300 相加结果是：" + calc.sum());
        System.out.println("100 比较 300，哪个大：" + calc.maxNum(100, 300));
    }
}

7、继承和组合的区别

长期的大量使用继承会给代码带来很大的维护成本。java的复用方式有继承、组合以及代理三种。
这里主要介绍继承复用和组合复用：

Java的继承与组合 (gitee.io)

继承是is-a关系，如狗是一个动物；组合是has-a关系，如狗有一个尾巴。

具体的区别可以见上面的文章。

组合的代码样例：

Java组合 - Java教程 (yiibai.com)

8、java是如何实现平台无关性的

Java如何实现的平台无关性的 (gitee.io)

具体的编译过程，编译原理课程中有详细提到过，这里不赘述，可以见下面的文章。

Java代码的编译与反编译那些事儿-HollisChuang's Blog

对于不同的硬件和操作系统，最主要的区别就是指令不同。那么想要跨平台，就是可以根据对应的硬件和操作系统生成对应的二进制指令。这一工作主要由java虚拟机完成。不同的操作平台需要下载对应的java虚拟机。

9、值传递

首先关于形参和实参：

实际参数是调用有参方法的时候真正传递的内容，而形式参数是用于接收实参内容的参数。

值传递、引用传递 (gitee.io)

为什么说Java中只有值传递 (gitee.io)

原始参数通过值传递给方法。这意味着对参数值的任何更改都只存在于方法的范围内。当方法返回时，参数将消失，对它们的任何更改都将丢失。

也就是说，引用数据类型参数(如对象)也按值传递给方法。这意味着，当方法返回时，传入的引用仍然引用与以前相同的对象。但是，如果对象字段具有适当的访问级别，则可以在方法中更改这些字段的值。

其实Java中使用的求值策略就是传共享对象调用，也就是说，Java会将对象的地址的拷贝传递给被调函数的形式参数。