Java基础

java重要的两大机制:一1.JVM虚拟机，2.垃圾回收机制

环境的配置

     java的环境变量的配置：

     1.在用户变量中新建一个JAVA_HOME,他的路径是jdk的目录路径：如：C:\Program Files\Java\jdk1.7.0_67

     2.在下面的path值后面加上一个分号";",然后把jdk安装目录下的bin目录的地址复制过来。

     3.现在的环境配置基本不需要配置classpath了.

  当用文本写代码的时候，cmd有些命令：

    javac:java编辑器

    java:java解释器

    jdb: java调试器

    javap:反编译，反编译的是.class文件（字节码文件）

    javadoc:文档生成器

---

Java的数据类型

     ①基本数据类型

      八大基本数据类型:

                                    整型：byte short int long

                                    浮点型:float  double

                                    字符型:char

                                    布尔型:boolean

     ②引用数据类型:

数组(冒泡排序，外层n-1，内层n-i-1，n为数组长度)，接口，类

     范围大小：byte<short<int<long<float<double

     同种基本类型之间可以转换，不同种不能转换。小类型转大类型不需要强制转换，大类型到小类型需要强制转换

---

运算符

   逻辑运算符：

    单个的&,|是不管第一个条件能不能决定结果，两个条件都必须执行完

    &&和||是短路的，只要第一个条件表达式能决定结果。第二个表达式就不执行

    i++，后加加

    ++i，前加加

     

                byte i = 1;

i++; //自动转型了

i = i +1;//会报错

    三元运算符:

    布尔表达式? 结果1（true）: 结果2（false）

    swith() case

    for  while  do - while

   continue 结束本次循环

   break 跳出循环

 

==与equals的区别

==是比较地址，地址会指向内存,因此在判断值相等的时候用==，字符串用equals来比较.

---

类与对象

类是对象的抽象，对象是类的实例化

访问修饰符

public:项目中任何地方可以访问

protected:在本类中，同包中，子类中可以使用

默认:在本类，同包中可以使用

private:只能在本类中使用

---

封装:

私有化属性，

创建对外的公开的方法

构造方法：

public 类名(){}

实例化对象的时候调用的方法,

如果类中没有构造方法，则会调用系统默认的无参构造方法，

若是自定义了构造方法则系统不会给无参的构造方法

构造方法的重载

同名方法在一个类中出现多次，但是参数类型，数量，顺序不一样。

类中方法的定义

方法有返回值，无返回值，有参数的，无参数的

形式参数：方法定义的时候才有

实际参数：在方法调用的时候才有

static关键字

static修饰的属性属于类所有，被对象所共享

static修饰的方法属于类所有，只能用静态的属性和方法

非静态的方法可以使用静态的方法和静态变量

类中只能有属性和方法，代码块

静态代码块是类一加载就加载，但是只加载一次.

加载顺序:静态变量初始化->静态代码块->静态方法->实例变量->代码块->构造方法

---

继承:

super:父类对象，可以访问父类中可以访问的属性和方法。

this：当前对象，不仅可以访问本类的属性和方法还能访问父类的属性和方法。

super和this都能调用构造方法，还应该在第一行.

1.在继承中，子类对象初始化时，先加载父类的构造方法，在加载子类的构造方法。

2.所有子类都默认调用父类的不参数的构造方法，如果父类自定义了一个代参构造方法，则子类要用super调用父类的代餐构造方法。

3.子类继承父类，能继承的修饰符public, protected的属性和方法.

不能继承的是private和默认的构造方法。

4.当父类类型指向子类对象的时候，只能调用父类的方法和属性，除非父类里的方法被子类给重写了。若要强制使用子类的方法和属性需要强制类型转换。

5.继承具有单一性：每一个类只有一个父类

6.继承具有传递性：比如a是b的父类，b又是c的父类，则c可以调用a的属性和方法。

---

final关键字

final修饰的变量，为常量，必须在声明的时候初始值，而且常量的值不能改变。

final修饰的方法不能被重写

final修饰的类不能被继承

---

多态

多态实现的两种形式：重载（overload），重写(override)

重载:一个类中方法名相同，但是参数的类型，数量，顺序不相同.

重写:子类重写父类的方法，方法名要一样，参数列表要一样，返回值类型不能比父类的大，修饰符权限大于等于父类被重写的方法的修饰符权限大。当父类类型指向子类对象的时候，调用的是子类的重写的方法，没有重写还是调用父类的方法。

a instanceof b  判断a对象是不是b类这个类型。

---

抽象(abstract)

抽象类是父类对子类的规定。

1. 抽象类中有抽象方法，也可以没有抽象方法，也可以有普通方法的具体实现。

2. 有抽象方法的类一定是抽象类

3. 子类继承了抽象类一定要实现抽象类中的抽象方法，除非子类也是抽象类。

4. 抽象类可以有构造方法，但是抽象类不能被实例化。

   
   

---

接口(interface)，实现接口implements

接口就是某个东西对外提供一些功能的申明.

    1.接口中有常量和方法的声明

    2.接口支持多继承，继承的类用逗号隔开。

    3.一个类实现接口必须实现接口中的未实现的方法

    4.一个类可以实现多个接口，用逗号隔开。

    5.接口中的常量public static final可以省略，public abstract也可以省略，接口是更加抽象的.

---

java中的包装类

基本数据类型       包装类

    byte                       Byte                             

    short                     Short

    int                          Integer

    long                       Long

    float                       Float

    double                   Double

    char                      Character

    boolean                 Double

装箱:基本数据类型转到包装类型

拆箱:包装类型转到基本数据类型

JDk1.5之后可以自动装箱拆箱

---

特殊的题目:

Integer i1 = 128;

Integer i2 = 128;

//在比较i1和i2

System.out.println(i1 == i2);//当i1和12在-128~127之间比较的时候结果为true，超过了则为false

---

String str1 = "abc";//分在常量区

String str2 = "abc";//当str2发现常量区有abc，则地址相同,则为true

System.out.println(str1 == str2);

---

String str1 = "abc";

String str2 = "abc";

str2 = new String("abc");//new 的时候又分配了一个内存，则地址又不相同了

System.out.println(str1 == str2);//则为false

---

String a = "abc";//在常量区有一个abc，则为创建了一个对象

String b = new String("abc");//new 的时候分配了一块内存，然后在常量区找到了abc，也创建了一个对象 

String c = new String("abc");//同理

//因此一共创建了3个对象

---

//字符串操作

String str3 = "hellowhave,hove";

System.out.println(str3.charAt(0));//获得下标为0的字符,为h

System.out.println(str3.indexOf('h',2));//查找h第二次出现的位置,为6

System.out.println(str3.lastIndexOf('h',9));//一直到9长度然后最后一次出现h的位置(0开始),为6

System.out.println(str3.substring(8));//截取从8开始之后的字符串, 结果为ve,hove

System.out.println(str3.substring(9, 11));//截取[9,11)之间的字符串

String s1 = "abc";

String s2 = "ABC";

System.out.println(s1.concat(s2));//拼接

System.out.println(s1.toUpperCase());//转大写

System.out.println(s2.toLowerCase());//转小写

System.out.println(s1 == s2);//false

System.out.println(s1.equals(s2));//false

System.out.println(s1.equalsIgnoreCase(s2));//true 不区分大小写

//endwith()方法

String s3 = "abc.txt";

System.out.println(s3.endsWith(".txt"));//判断以什么结尾，返回boolean值

---

//StringBuffer操作,可对字符串操作

StringBuffer sb = new StringBuffer();

sb.append("每天不不一样");//追加字符串

sb.delete(0, 2);//删除[0,2)之间的字符

sb.deleteCharAt(1);//删除下标为1对应的字符

sb.insert(5, '哈');//在下标为5的位置插入'哈'

System.out.println(sb);

---

//随机数

Random random = new Random();

int rand = random.nextInt(5);//产生[0,5)之间的随机数

Math.random()//产生[0,1)之间的随机数

---

//日期函数

//date转换成字符串

Date date = new Date();

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

System.out.println(sdf.format(date));

// 字符串转成时间

String s6 = "2012-10-20 20:10:10";

try {

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//如果是hh则时间是12进制的，HH是24进制的

Date parse1 = sdf.parse(s6);

System.out.println(parse1);

} catch (ParseException e) {

e.printStackTrace();

}

// Calendar类获取时间

Calendar cal = Calendar.getInstance();

System.out.println(cal.get(Calendar.MONTH));//得到月份从0开始

cal.set(2020, 10, 20);//设置日期

cal.add(Calendar.DAY_OF_MONTH, 2);//在这个月上加2天

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

System.out.println(sdf.format(cal.getTime()));//得到当前的时间

---

a+=b  --> a=(a.Type)a+b;//返回的是a类型
a=a+b --> a=a+b;//返回类型是a类型与b类型中的最高类型