java常识

几个命令行目录
dir 列出当前目录下的文件
md 创建目录
rd 删除目录
cd 进入目录
cd/回退到根目录
cd..回退到上一级目录
echo 创建文件 echo 内容 >1.txt
del 删除文件
exit 退出命令行

jdk：java开发工具包，包括javac编译等java工具(bin目录下)、jre、 以及基础类库(lib目录下)
jre：java运行环境，包括jvm（jre/bin目录下）,jvm需要的类库(jre/lib目录)
jvm：java跨平台根本，一处编译，处处运行。只要编译成.class目标文件，有了jvm，能在各种操作系统上运行。

javac编译
java运行

为什么要配置环境变量？
在任意目录下运行在 Java安装目录下的可执行文件（比如java,javac等）

一、参数

1.java中参数总是按值传递：
    形参是基本数据类型的：将实参的值传递给形参的基本数据类型的变量
2.参数有显示参数与隐式参数：将实参引用类型变量的值（对应堆空间的地址）传递给形参的引用类型变量
3...int多值传参

二、封装（数据隐藏）

 1.啥是封装？不能让类中的方法直接访问其他类中的属性，只能通过方法来访问其他类中的属性
    就是属性私有化和提供公共的方法来访问其他类的属性
2.权限修饰符

属性和方法：
    private:类内部
    缺省：类内部、包
    protected:类内部、包、子类
    public:类内部、包、子类、任何地方
类：一般用public和缺省

3.this的用途：

    隐式传参；
    调用该类的其他构造函数: this();

三、继承

1.super关键字
    调用超类中的属性和方法；当父类与子类中的重名时
    调用超类中的构造器       
2.实例化的过程
    隐式或显示得调用父类中的构造器

四、多态

1.多态性：

    方法的重写与重载；
    子类对象的多态性（对象变量的多态性）：父类的引用指向子类对象（子类也是一个父类）
2.强制类型转换时候可能会出现错误，可以预先判断一下（instanceof）

五、equal和==

==：
    1.基本数据类型，根据基本数据类型的值判断是否相等（数据类型不同也可能返回true）
    2.引用数据类型，比较引用数据类型变量的地址值是否相等

六、string类型的内存

七、各种包装类

尖括号中的类型参数不允许是基本数据类型，也就是说，不允许写成ArrayList<int>,在这里用到Integer

包装类和基本数据类型之间的转换：自动拆装箱

包装类和基本数据类型====string
    包装类和基本数据类型--->string,String.valueof()
    string--->包装类和基本数据类型,相应包装类的parsexxx()或者是调用包装类的构造器

八、static

可以修饰属性、方法、代码块、内部类的修饰

修饰属性（类变量）：属于一个类的变量 VS 实例变量
修饰方法（类方法）：

九、类的初始化块

类的初始化数字域的方法：①默认初始化②显示初始化语句和初始化域（按照顺序结构执行）③在构造器中

数据域赋值的顺序：
    ①所有数据域被初始化为默认值（0，false,null）
    ②按照在类声明中的次序，依次执行所有初始化语句和初始化块（初始化语句与初始化块之间按顺序结构执行）
    ③构造器
修饰词只有static
非静态的代码块：
    可以对类的属性进行初始化操作；
    里面可以有输出语句；
    可以有多个非静态的代码块，按照顺序结构执行； 
    每创建一个类的对象，非静态代码块就加载一次
静态的代码块：
    随着类的加载而加载，只被加载一次；
    静态代码块的执行要早于非静态代码块的执行；
    只能执行静态的结构

十、final关键字

可以修饰类、方法、属性
修饰类：这个类就不能被继承
修饰方法：该方法不能被重写
修饰属性：该属性就是一个常量（此常量没有默认初始化；可以显示赋值、代码块、构造器）

public class TestFinal {
    public static void main(String[] args) {

    }

    不正确
    public int addOne(final int x){
        return ++x;
    }
    //正确，因为x引用的地址木有变
    public Other add(final Other x){
        x.i++;
        //x = new Other();不对，x引用的地址变了
        return x;
    }

}

class Other{
    public int i;
}

十一、abstract
abstract可以修饰类、方法，不能用abstract修饰属性、私有方法、构造器、静态方法、 final的方法

修饰类：
    抽象类没有实例；
    有构造器（凡是类都有构造器）；
    如果一个类没有全部实现抽象父类中的抽象方法，则还是这个子类抽象的
修饰方法:
    木有方法体实现，交给子类来重写；
    抽象方法所在的类一定是抽象类  ；
    抽象类中可以没有抽象的方法

十二、接口
常量：public static final，不管显示还是不显示，都是public static final
抽象方法：
接口与接口之间也是继承的关系而且能够实现多继承，类与接口之间是实现的关系

十三、内部类:定义在另一个类内部的类

**内部类的分类:
    成员内部类,(类内部,方法外)
    局部内部类,(类的方法里)
成员内部类：
    是外围类的一个成员：①有修饰符（4个）②可以用static/final/abstract修饰③可以调用外围类的成员方法
    具有类的特点:可以在内部定义属性、方法、构造器
局部内部类：


如何创建成员内部类的对象：
如何区分调用内部类与外围类的变量：（重名情况下）
局部内部类的使用：**

**

**如何创建成员内部类的对象
    public class TestInner {
    public static void main(String[] args) {
        //如何创建成员内部类的对象
        //静态的
        Person.Dog dog = new Person.Dog();
        //非静态的：先创建一个外围类的对象
//        Person.Bird bird = new Person.Bird();不对
        Person person = new Person();
        Person.Bird bird = person.new Bird();
        bird.info();
        //如何区分调用成员内部类和外围类中重名的属性
        bird.setName("杜鹃");
    }
}
class Person{
    String name = "韩梅梅";
    int age;
    //成员内部类（非静态的）
    class Bird{
        String name = "黄鹂";
        int id;
        public Bird() {
        }
        public void setName(String name) {
            System.out.println(name);//调用传进的参数
            System.out.println(this.name);//调用成员内部类的属性
            System.out.println(Person.this.name);//调用外围类的属性
        }
        public void info(){
            show();
        }
    }
    //成员内部类（静态的）
    static class Dog{
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public void show(){
        System.out.println("我是show()方法");
    }
}
//局部内部类的使用
public class TestInner1 {
}
class OuterClass{
    public void method1(){
        //局部内部类
        //以下这种使用方法较为少
        class InnerClass{
        }
    }
    //常常使用一个方法，其返回值为某个类或接口的对象，而这个类或接口在方法内部创建
    //使用方法一（有名的）
    //返回值为Comparable接口的一个对象
    public Comparable getComparable(){
        //1.创建一个实现Comparable接口的类
        class MyComparable implements Comparable{
            @Override
            public int compareTo(Object o) {
                return 0;
            }
        }
        //返回一个实现类的对象
        return new MyComparable();
    }
    //使用方式二（匿名内部类）
    public Comparable getComparable1(){
        return new Comparable() {
            @Override
            public int compareTo(Object o) {
                return 0;
            }
        };
    }
}**