Java基础笔记

类：是一组具有类似属性和行为的集合。可以看成一类事物的模板，使用事物的属性特征和行为特征来描述该类事物
对象：是一类事物的具体体现。对象是类的一个实例，必然具备该类事物的属性和行为。

类是对一类事物的描述，是抽象的
对象是一类事物的实例，是具体的
类是对象的模板，对象是类的实体

类的定义：
访问权限修饰符 class 类名 {
//成员变量 属性特征
//成员方法 行为特性
}

对象的创建：
类名 对象名 = new 类名();

使用对象访问类中的成员：
对象名.成员变量；
对象名.成员方法()；

方法定义：
访问权限修饰符 静态修饰符 返回值类型 方法名（参数类型 参数名,参数类型 参数名...）｛
执行代码...
return 返回语句;
｝

方法只能定义在类中，不支持方法中再嵌套定义方法。
嵌套会引发编译错误。

返回值类型，必须要和return语句返回的类型相同或者比返回值类型范围小，否者编译失败。

不能再return后面写代码，return意味着结束，后面的所有代码不会执行。

void表示无返回值，可以省略return，也可以写return，后面不加数据。

方法重载：
指在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同即可，与修
饰符和返回值类型无关。
多个方法在同一个类中
多个方法具有相同的方法名
多个方法的参数不相同，类型不同或者数量不同
注意：参数列表：个数不同，数据类型不同，顺序不同。
重载方法调用：JVM通过方法的参数列表，调用不同的方法。

递归 求N的阶乘。
public class test06 {
    public static void main(String[] args) {
           int i= get(3);
        System.out.println(i);
    }
    public static int get(int n){
        if(n==1){
            return 1;

        }else {
            int  i=n*get(n-1);
            return i;
        }

    }
}
注意：
递归方法可以使用重复方法、少量代码，即可实现复杂功能的实现；
递归方法一定要有出口，否则无限递归调用，直到出现StackOverflowError（栈内存溢出）错
误；
递归方法的递归次数也不能过多，否则同样出现StackOverflowError（栈内存溢出）错误；
递归方法都可以使用非递归方法解决，比如循环。

static 成员变量：静态变量
静态变量被所有对象共享，在内存中只有一个副本，在类初次加载的时候才会初始化；
非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的
副本互不影响；

static 方法：静态方法
由于静态方法不依赖于任何对象就可以直接访问，因此对于静态方法来说，是没有this的；
静态方法中不能访问类的非静态成员，因为非静态成员变量和非静态方法都必须依赖于具体
的对象才能被调用；
static方法通常作用一个工具类中统一对外提供的方法使用，比如之前学习的Arrays数组工具
类中的方法都是static的。

static代码块：静态代码块，用于类的初始化操作。
static代码块随着类的加载而加载，并且只初始化执行一次；
静态初始化块中不能直接访问非static成员；
静态初始化块可以置于类中的任何地方，类中可以有多个静态初始化块，多个静态代码块会
按照书写顺序加载。

单例模式
构造函数是私有的private
1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。

代码实现
懒汉式 线程不安全
public class Singleton {
    private static Singleton instance;
    private Singleton(){}
    public static Singleton getInstance(){
        if(instance==null){
            instance=new Singleton();
        }
        return instance;
    }
}
饿汉式
public class Singleton {
   private static Singleton instance = new Singleton();
   private Singleton (){}
   public static Singleton getInstance() {
        return instance;
   }
}
单例模式优缺点和应用场景 ：https://www.cnblogs.com/restartyang/articles/7770856.html
我在这里看到。==

package
作用：package包其实就是目录，通常情况下，我们会对文件进行分文别类来管理，在Java中分包管理，包名称通常采用小写
package 包名；
package com.wei.test;
package语句只能出现在Java源文件的第一行；
package定义的格式，通常采用公司域名倒叙方式，例如com.myhopu.oa。
在Java中使用package语句定义包，多级包名之间用逗号“.”分隔(单包，复包)；

import
作用：导入不同包下的类。要用其他包类中的方法，要先导入包下的类，才可以使用，否则会编译报错。
import导包语句必须放在package语句与class类之间；
同包下的类使用时无需使用import引入，直接使用即可；
在使用java.lang包下的所以类时，无需import引入。java.lang包是Java的基础核心包，Java在编译期间会自动引入该包；
可以使用'*'导入包下的所有类。

封装：主要是将类中的部分代码实现细节封装起来，外面不可以直接访问；
继承：主要是提高了代码的可重用性和可扩展性。多态的前提。
多态：包括设计时多态和运行时多态，通过调用不同参数或名称的方法来决定父类对象动态调用哪
个子类方法，增强了代码的灵活度。

封装类：
public clss 外部类名{
private class 内部类名{ 内部类成员 }
外部类成员
}

使用：
public class test07 {
    private class user{
        public void test(){
            System.out.println("fusag");
        }
    }

    public static void main(String[] args) {
        test07 t=new test07();
        user u=t.new user();
        u.test();
    }
}

访问修饰符
public：公共的
protected：受保护的
default：默认的（不用写的）
private：私有的

---------------------------------------------------------------------------
            public     protected     default      private
---------------------------------------------------------------------------
同一类中             ✔          ✔             ✔              ✔
---------------------------------------------------------------------------
同一包中（子类于无关类）    ✔          ✔             ✔              
---------------------------------------------------------------------------
不同的包的子类        ✔          ✔             
---------------------------------------------------------------------------
不同包中的无关类        ✔          
---------------------------------------------------------------------------

继承后的特点
成员变量重名：
class Fu{
    int num=3;
}
class Zi extends Fu{
    int num=5;
    public void show() {
// 访问父类中的num
        System.out.println("Fu num=" +super.num);
// 访问子类中的num
        System.out.println("Zi num=" + num);
    }

}
public class test07 {
    

    public static void main(String[] args) {

        Zi z = new Zi();
        // 调用子类中的show方法
        z.show();
       //结果:Fu num=3
      Zi num=5
    }
}
//子类中访问父类中非私有成员变量，需要使用super关键字。
成员方法重名：
如果子类出现与父类重名方法，但是方法参数不同，这种情况属于方法重载；
如果子类出现与父类重名方法，同时方法参数也相同，这种情况叫做方法重写Override。
//如果是父类的私有方法，因为根本无法继承，所以不存在重写。
注意：
子类方法覆盖父类方法，必须要保证权限大于等于父类权限。
子类方法覆盖父类方法，方法名和参数列表都要一模一样。
子类方法覆盖父类方法，返回值类型可以与父类保持一致，或者返回父类返回值的子类。
私有方法不是不能继承，而是无法访问，所以不能重写。

构造方法：
构造方法的名字是与类名一致的。所以子类是无法继承父类构造方法的。
构造方法的作用是创建对象并初始化成员变量的。所以子类的初始化过程中，必须先执行父类的初
始化动作。子类的构造方法中默认有一个 super() ，表示调用父类的构造方法，父类成员变量初始
化后，才可以给子类使用。

在每次创建子类对象时，先初始化父类空间，再创建其子类对象本身。目的在于子类对象中包含了其对
应的父类空间，便可以包含其父类的成员，如果父类成员非private修饰，则子类可以随意使用父类成
员。代码体现在子类的构造方法调用时，一定先调用父类的构造方法。

final:最终的
final修饰类：表示最终类，也就是此类不能被继承；
final修饰变量：表示常量，也就是一个变量的值始终如一，无法变更；
final修饰方法：表示最终方法，也就是此方法不能被重写。

被final修饰的成员变量，必须进行初始化赋值，且值不能变更，否则编译出错；
被final修饰的成员变量，通常会结合final和static关键字一起使用，表示一个全局的静态常量，常
量名用大写；
被final修饰的局部变量，不能使用static修饰，同时可以不用先初始化赋值，使用时进行一次赋值
即可，后续也不能变更；
final修饰基本数据类型，表示该基本数据类型的值一旦在初始化后便不能发生变化；
final修饰引用数据类型，则在对其初始化之后便不能再改变引用地址了，但该引用所指向的对象
的内容是可以发生变化的。

Java只支持单继承，不支持多继承

抽象类
当定义了抽象函数的类也必须被abstract关键字修饰，被abstract关键字修饰的类是抽象类。

抽象方法 ：没有方法体的方法。
抽象类：包含抽象方法的类。

使用 abstract 关键字修饰方法，该方法就成了抽象方法，抽象方法只包含一个方法名，而没有方法体。
修饰符 abstract 返回值类型 方法名 (参数列表)；
如果一个类包含抽象方法，那么该类必须是抽象类
修饰符 abstract class 类名字 {
    抽象方法
}
注意：
1. 抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。
2. 抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。
3. 抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
4. 抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也
是抽象类。

接口
是Java语言中一种引用类型，是方法的集合，如果说类的内部封装了成员变量、构造方法和成员
方法，那么接口的内部主要就是封装了方法，包含常量、抽象方法（JDK 7及以前），默认方法和静态
方法（JDK 8）。
定义：
public interface 接口名称 {
// 常量
// 抽象方法
// 默认方法
// 静态方法
}
说明：在JDK 8之前，Java接口中只包括常量与抽象方法，从JDK8开始，接口中新增了默认方法与静态
方法。
实现：
修饰符 class 类名 implements 接口名 {
// 重写接口中抽象方法【必须】
// 重写接口中默认方法【可选】
}

静态方法
修饰符 static 返回值类型 方法名 (参数列表){
方法体
}
注意：
静态方法使用 static 关键字修饰，不可省略，供接口直接调用；
静态方法不能被继承，也不能被重写；
静态方法只能通过接口名直接调用。

默认方法
修饰符 default 返回值类型 方法名 (参数列表){
方法体
}
注意：
默认方法使用 default 关键字修饰，不可省略，供子类调用；
默认方法可以被子类继承、同时也可以被子类重写，被子类实现时必须去除default关键字。
默认方法只能被实现类对象调用。
default方法只允许在接口中定义。