java基础

常见的dos命令
盘符： 进入指定的盘符下。
dir : 列出当前目录下的文件以及文件夹
md : 创建目录
rd : 删除目录 注意：rd不能删除非空的文件夹，而且只能用于删除文件夹。
cd : 进入指定目录
cd.. : 退回到上一级目录
cd \ : 退回到根目录
echo “hello java”>a.txt 写入文本到指定文件
type a.txt 显示文件内容命令
del : 删除文件 注意：不能删除文件夹，只能删除文件。
exit : 推出dos命令行
cls : 通知计算机将当前的命令清空
*: 是通配符。
tab 命令补全。
方向键上下是找回上次你写过的命令。

JDK目录介绍
1.bin目录：存放Java的编译器、解释器等工具(可执行文件)。
2.db目录：JDK7附带的一个轻量级的数据库，名字叫做Derby。
3.include目录：存放的调用系统资源的接口文件。
4.jre目录：存放Java运行环境文件。Java runtime environment
5.lib目录：存放Java的类库文件。
6.src.zip文件：JDK提供的类的源代码。

1.简述对JVM,JRE,JDK的理解。
JVM虚拟机相当于计算机系统（操作系统+硬件环境）
jre = java虚拟机 + 核心类库(辅助java虚拟机运行的文件)
jdk = jre + java开发工具
2.简述环境变量path和classpath的作用？
搭建环境变量path 可以在任意目录下运行对应目录的所有软件
3.class的作用,javac,java的作用？
class 存放代码 javac 编译代码 Java 执行代码

文档注释 （编写软件说明书）
文档注释用/* /表示，是java特有的注释，其中注释内容可以被JDK提供的工具 javadoc 所解析，生成一套以网页文件形式体现的该程序的说明文档。
1.需要使用sum给我们提供的javadoc工具生成一个html的说明文档。
2.只能抽取public的属性或者方法内容。
格式：
Javadoc –d 指定存储文档的路径 -version –author（可选） 目标文件

@author 作者
@version 版本
@param 方法的参数
@return 返回值

强制类型转换（也叫显式类型转换）
所有的byte型、short型和char的值将被提升到int型。
不可以将一个数值赋给范围更小数值范围的变量，除非进行类型转换。
byte b = 100;
b = b + 2;
System.out.println(b);
上述例子发生了什么，发生了类型转换。
b+2 遇到了加法运算，2默认是int类型，byte类型b变量存储的值自动类型提升为
了int类型。执行完加法运算后的结果就是int类型，想要将int的类型值放入到byte类型变量b中，无法放入，编译报错。

Outer :for(int i=0;i<5;i++)

1、函数重载的定义：在同一个类中，有一个以上的同名函数，只要函数的参数列表或参数类型不一样即可，与返回值无关， 这些统称为方法的重载。
2、函数的重载存在的原因：为了增强方法的阅读性，优化了程序设计。

数组：
int[] arr = new int[5];
int[] arr = new int[]{3,5,1,7};
int[] arr = {3,5,1,7};
二维数组长度

面向对象的特征
封装(encapsulation)
继承(inheritance)
多态(polymorphism)

成员变量与局部变量的区别：
1.应用范围
成员变量在整个类内都有效
局部变量只在其声明的方法内有效
2.生命周期
成员变量: 它属于对象，它随着对象的创建而创建，随着对象的消失而消失
局部变量: 使用完马上释放空间。
3.存储位置 成员变量属于对象，它存储在堆内，堆内的实体，当没有引用指向其时，才垃圾回收清理 局部变量存在栈内存中，当不在使用时，马上就会被释放。
4.初始值
成员变量它存储在堆中，如果没有赋初值，它有默认值。
1.整数byte、short、int、long =0；
2.char=’\uoooo’；
3.boolean =flase；
4.String =null;
5.类类型 =null；
6.数组 =null；
局部变量，如果要想使用必须手动初始化.
i.方法中，参数列表中，语句中。
ii.必须给初始化值，没有初始值，不能使用
iii.在栈内存中

匿名对象
没有名字的实体，也就是该实体没有对应的变量名引用。
匿名对象的用途
1，当对象对方法进行一次调用的时候，可以使用匿名对象对代码进行简化。
为什么只对方法，而不调用属性呢？因为匿名对象调用属性没意义。
如果对象要多成员进行多次调用，必须给对象起个名字。不能在使用匿名对象。
2，匿名对象可以实际参数进行传递。
2：匿名对象的简单演示
1：new Car().run();
3：内存结构图
1：new Car().num=5;
2：new Car().clor=”blue”;
两个new 是两个不同的对象，在堆内存中有不同的空间，相互不相互干扰。
4：匿名对象的使用
1：当只使用一次时可以使用匿名对象。执行完毕到;后该对象就变成了垃圾。
new Car().run();
2:执行方法时，可以将匿名对象作为实际参数，传递进去。

1.匿名对象设置的属性永远无法获取？ 没有引用变量指向那个对象。
2.任何两个匿名对象使用==比较，永远返回false。
3.匿名对象主要应用于实参。

封装的实现
1：设置类的属性为private(关键字)，不能使用对象名.属性名的方式直接访问对象的属性。

package oop01;

public class EmployeeDemo {
    public static void main(String[] args) {
        // 创建对象
        Employee jack = new Employee();

        // 调用公有方法，给成员变量赋值。
        jack.setId("007");
        jack.setName("jack");
        jack.setGender("男xx");

        // 获取实例变量的值
        System.out.println(jack.getGender());
        System.out.println(jack.getId());
        System.out.println(jack.getName());

        // 调用成员方法
        jack.work();

    }
}

class Employee {
    private String name;
    private String id;
    private String gender;

    // 提供公有的get set方法
    public String getName() {
        return name;
    }

    public void setName(String n) {
        name = n;
    }

    public String getId() {
        return id;
    }

    public void setId(String i) {
        id = i;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gen) {
        if ("男".equals(gen) || "女".equals(gen)) {
            gender = gen;
        } else {
            System.out.println("请输入\"男\"或者\"女\"");
        }

    }

    public void work() {
        System.out.println(id + ":" + name + ":" + gender + " 努力工作中！！！");
    }
}

封装的好处
1：隐藏了类的具体实现
2：操作简单
3：提高对象数据的安全性

构造方法作用：对象进行初始化

构造函数与普通的函数的区别
1.一般函数是用于定义对象应该具备的功能。而构造函数定义的是，对象在调用功能之前，在建立时，应该具备的一些内容。也就是对象的初始化内容。
2.构造函数是在对象建立时由jvm调用, 给对象初始化。一般函数是对象建立后，当对象调用该功能时才会执行。
3.普通函数可以使用对象多次调用，构造函数就在创建对象时调用。
4.构造函数的函数名要与类名一样，而普通的函数只要符合标识符的命名规则即可。
5.构造函数没有返回值类型。

构造函数注意的细节
1. 当类中没有定义构造函数时，系统会指定给该类加上一个空参数的构造函数。这个是类中默认的构造函数。当类中如果自定义了构造函数，这时默认的构造函数就没有了。
备注：可以通过javap命令验证。
2.在一个类中可以定义多个构造函数，以进行不同的初始化。多个构造函数存在于类中，是以重载的形式体现的。因为构造函数的名称都相同。

构造代码块作用：给所有的对象进行统一的初始化。
1：给对象进行初始化。对象一建立就运行并且优先于构造函数。
2：与构造函数区别
1：构造代码块和构造函数的区别，构造代码块是给所有对象进行统一初始化， 构造函数给对应的对象初始化。
2：构造代码块的作用：它的作用就是将所有构造方法中公共的信息进行抽取。

this是什么？
this关键字代表是对象的引用。也就是this在指向一个对象，所指向的对象就是调用该函数的对象引用。this和p是一样的都是内存地址值。

细节：
1.构造函数的相互调用在编译时期会报错
2.this只能在非静态中（没有static修饰的）函数使用
3.构造函数间相互调用必须放在构造函数的第一个语句中，否则编译错误
4.可以解决构造函数中对象属性和函数形参的同名问题。

static关键字
变量如何放入共享区？对象如何访问？
内存分析：栈，堆、共享区
使用static
static 为了实现对象之间重复属性的数据共享
static使用
1：主要用于修饰类的成员
1：成员变量
非静态成员变量：需要创建对象来访问
静态成员变量：使用类名直接调用，也可以通过对象访问
2：成员方法
可以使用类名直接调用
1：静态函数：
1：静态函数中不能访问非静态成员变量，只能访问静态变量。
2：静态方法不可以定义this,super关键字.
3：因为静态优先于对象存在.静态方法中更不可以出现this
2：非静态函数：非静态函数中可以访问静态成员变量
细节：
1：静态函数中不能使用非静态变量
2：非静态函数可以访问静态变量
为什么静态函数中不能访问非静态成员
1：static修饰的成员在共享区中。优先于对象存在
2：验证
1：使用静态代码块验证
1：静态代码块
static{
静态代码块执行语句;
}
1：静态代码块特点
随着类的加载而加载。只执行一次，优先于主函数。用于给类进行初始化。
static特点
1 随着类的加载而加载，静态会随着类的加载而加载，随着类的消失而消失。说明它的生命周期很长。
2 优先于对象存在。–>静态是先存在，对象是后存在。
3 被所有实例(对象)所共享。
4 可以直接被类名调用
静态变量（类变量）和实例变量的区别:
1存放位置
1：类变量随着类的加载而加载存在于方法区中.
2：实例变量随着对象的建立而存在于堆内存中.
2生命周期
1：类变量生命周期最长,随着类的消失而消失.
2：实例变量生命周期随着对象的消失而消失.
静态优缺点
1： 优点:对对象的共享数据进行单独空间的存储,节省空间 例如Person 都有
国籍。该数据可以共享可以被类名调
2：缺点：生命周期过长
访问出现局限性。（静态只能访问静态）
什么时候定义静态变量
1:静态变量（类变量）当对象中出现共享数据
例如：学生的学校名称。学校名称可以共享
对象的数据要定义为非静态的存放在对内存中（学生的姓名，学生的年龄）
什么时候定义静态函数
如果功能内部没有访问到非静态数据（对象的特有数据。那么该功能就可以定义为静态）
静态的应用
自定义数组工具类

单例设计模式
解决一个类在内存中只存在一个对象，想要保证对象的唯一。
1 为了避免其他程序过多的建立该类对象。禁止其他程序建立该类对象。
2 为了其他程序可以访问该类对象，在本类中自定义一个对象。
3 方便其他程序对自定义类的对象的访问，对外提供一些访问方式。
代码：
1将构造函数私有化
2在类中创建一个私有的本类对象
3提供一个用类名调用的公有方法获取该对象。

class Single {

    private static Single s = new Single(); // 恶汉式

    private Single() {

    }

    public static Single getInstance() {
        return s;
    }
}

class Single2 {
    private static Single2 s = null; // 懒汉

    private Single2() {

    }

    public static Single2 getInstance() {
        if (s == null) {
            s = new Single2();
        }
        return s;
    }
}

继承
继承细节；
1：类名的设定，被继承的类称之为父类(基类)，继承的类称之为子类
2：子类并不能继承父类中所有的成员
1：父类定义完整的成员 静态成员，非静态，构造方法。静态变量和静态方
法都可以通过子类名.父类静态成员的形式调用成功。
2：所有的私有成员不能继承,private修饰的成员。
3：构造函数不能被继承

super关键字
super关键字作用
1：主要存在于子类方法中，用于指向子类对象中父类对象。
2：访问父类的属性
3：访问父类的函数
4：访问父类的构造函数
super注意
this和super很像，this指向的是当前对象的调用，super指向的是当前调用对象的父类。Demo类被加载，执行main方法，Son.class加载，发现有父类Father类，于是Father类也加载进内存。类加载完毕，创建对象，父类的构造方法会被调用（默认自动无参），然后执行子类相应构造创建了一个子类对象，该子类对象还包含了一个父类对象。该父类对象在子类对象内部。this super只能在有对象的前提下使用，不能在静态上下文使用。

子类的构造函数默认第一行会默认调用父类无参的构造函数，隐式语句
super();
父类无参构造函数不存在，编译报错。

super思考
如果开发者自定义了一个类，没有显示的进行类的继承，那么该类中成员函数是否可以使用super关健健字？可以使用，继承了Object类，Object类是所有类的父类。

class Demo7 {
    public  void print(){
        System.out.println(super.toString());
    }
    public static void main(String[] args){
        new Demo7().print();
        System.out.println();
        }
}

重写（Override）
在继承中，子类可以定义和父类相同的名称且参数列表一致的函数，将这种函数
称之为函数的重写.
前提
1：必须要有继承关系
特点
1：当子类重写了父类的函数，那么子类的对象如果调用该函数，一定调用的是重写过后的函数。
可以通过super关键字进行父类的重写函数的调用。
2： 继承可以使得子类增强父类的方法
细节
1： 函数名必须相同
2：参数列表必须相同
3： 子类重写父类的函数的时候，函数的访问权限必须大于等于父类的函数的访
问权限否则编译报错
4：子类重写父类的函数的时候，返回值类型必须是父类函数的返回值类型或该返回值类型的子类。不能返回比父类更大的数据类型： 如子类函数返回值类型是Object

重载和重写的不同
1：重载(overload)：
1：前提： 所有的重载函数必须在同一个类中
2：特点：
函数名相同，参数列表不同，与其他的无关(访问控制符、返回值类型)
3：不同：
个数不同 、 顺序不同、 类型不同
2：重写(override)：
1：前提： 继承
2：特点：
函数名必须相同、参数列表必须相同。
子类的返回值类型要等于或者小于父类的返回值

instanceof 关键字
该关键字用来判断一个对象是否是指定类的对象。

final关键字
public static final double PI=3.14;
1：public ：访问权限最大
2：static ：内存中只有一份
3：final ：是一个常量
4：常量名大写
5：必须初赋值。

为什么子类一定要访问父类的构造函数呢
1：子类继承了父类的属性，如果要使用父类的属性必须初始化，创建子类对象，必须先初始化父类属性
必须调用父类的构造方法。
2：为什么调用父类无参的构造函数
设计java语言之时，只知道编译器会默认添加无参的构造函数，有参的无法确定。
但是可以通过super关键字显式调用父类指定构造函数。
3：为什么super()this()语句要放在构造函数的第一行
子类可能会用到父类的属性，所以必须先初始化父类。