跟韩老师学java

入门阶段：

1.文档注释:

/**

* @author   名字（作者）

*@version  1.0（版本）

*/

2.相对路径和绝对路径

相对路径：从当前目录开始定位，形成的路径

绝对路径：从顶级目录开始定位形成的目录

需求：从D:\abc\test100 访问D:\abc2\test100\hello.txt

相对路径：..\..\abc\test100\hello.txt(..表示上一级)

绝对路径:D:\abc2\test100\hello.txt

Dos命令：cls：清屏     tree 目录：查看目录下的子目录（生成一个树）

3.加号“+”的使用：

当两边都是数字时做加法运算；当左右有一方为字符串，做拼接运算；运算顺序为从左到右

System.out.println("100"+98)结果为10098

System.out.println(100+3+hello)结果为103hello

System.out.println("hello"+100+3)结果为hello1003

4.基本数据类型

整型：byte[1],short[2],int[4],long[8]

浮点型（小数）：float[4],double[8]注：1字符=8字节

字符型：char[2]存放单个字符

布尔类型：boolean[1]存放true和false

5.引用数据类型

类（class）

接口（interface）

数组（{}）

6.关于浮点型：

浮点数=符号位+指数位+尾数位

尾数部分可能丢失，造成精度损失（小数都是近似值）

7、自动类型转换细节：

当不同类型混合运算时，先自动将数据转换成容量最大的那种数据类型，然后进行计算

数据类型;byte->short->int->long->float->double(精度由小到大)

char->int->long->float->double

当把精度大的数据类型赋值给小的数据类型的时候，就会报错。

例：int a = 10

float b = a + 1.1则程序会报错

若float b = a + 1.1F则不会报错。

byte = 10;//当把一个数赋值给byte会先判断该数是否在byte范围内，如果是就可以。 

当把一个变量赋值的时候会先判断类型。

byte、short、char三者进行运算，先将精度转换成int然后再进行运算

故byte a = 1；

short b = 2；

short c = a+b //会报错

byte d = 3；

byte e = a+d；//也会报错

表达式结果类型自动提升为操作数中最大的类型

进行复合赋值运算符会有个强制的类型转换

byte b = 3 ；  b + = 2//强制类型转换，将b+2转换为byte型，b++同理

取余的计算：a%b=a - a / b * b

8、switch分支结构

表达式数据类型，应和case后的常量类型一致，或者是可以自动转成可以相互比较的类型，比如输入的是字符，而常量是int

switch（表达式）中表达式的返回值必须是（byte，short，int，char，enum，String）

case子句中的值必须是常量，而不能是变量

default子句是可选的，当没有匹配的case时，执行default

break语句用来在执行完一个case分支后使程序跳出switch语句块；如果没有写break，程序会顺序执行到switch结尾

9、continue

continue会跳过此次循环，进入到下一次循环

如for(int i=0;i<4;i++){if(i==2)continue;System.out.println(i)}

输出结果是0和1和3

10、数组

动态初始化：（指定长度）数据类型[] 数组名字 = new 数据类型[数组长度]；

数据类型 数组名字[] = new 数据类型[数组长度]；

可拆分         int[] arr;  

                arr=new int[3]

注意：数组有订定长特性，长度一旦指定就不可以更改

静态初始化：（指定内容）

数据类型[] 数组名 = new 数据类型[]{元素一，元素二，元素三}

可拆分           int arr[];  

                arr =new int[]{1、2、3、4、5}

11、二维数组

        从定义形式上看int[][]

        可以理解为原来的一维数组的每个元素是一维数组，就构成二维数组

内存结构：

 二维数组列数可以不相同：即int[][] arr = new int [3][];

12、Java对象

对象在内存中的形式

Cat cat = new cat();

cat.name = '小白';

cat.age = 12;

cat.color = '白色';

 定义：访问修饰符 属性类型 属性名；

四种访问修饰符：public,protected,默认,private

属性的定义类型可以为任意类型，包含基本类型或引用类型

属性如果不赋值，有默认值，规则和数组一致

Java创建对象的流程简单分析

        先加载类信息（属性和方法信息，只会加载一次）        

        在堆中分配空间，进行默认初始化（看规则）

        把地址付给（对象名）比如p，o就指向对象

        进行指定初始化

 同一个类中的方法调用：直接调用即可

跨类中的方法调用：A类调用B类方法：需要通过对象名调用。例：对象名.方法名（参数）

引用类型传递的是地址（传递也是值，但是值是地址）可以通过形参影响实参

public String  方法名 （String name ，double... scores）其中，double... scores 是可变参数，即不确定参数个数，必须放在方法声明的最后一行，并且一个里面只能有一个。

属性和全局变量可以加修饰符，局部变量不能。

13、构造方法/构造器

构造器的修饰符可以默认，也可以是public、pravite、protected

构造器没有返回值

方法名和类名必须一样

参数列表和成员方法一样的规则

构造器的调用系统完成

14、对象创建流程分析

        加载person类信息（person.class），只会加载一次

        在堆中分配空间（地址）

        完成对象初始化（默认初始化age = 0,name = null ->显式初始化 age = 90 name = null,->构造器初始化 age=20 name = 小倩）

        在对象在堆中的地址，返回给p（p是对象名）也可以理解成是对象的引用

15、this

this关键字可以用来访问本类的属性

哪个对象调用，this就代表哪个对象

this只在类定义的内部使用，不能在类定义的外部使用

16、包

命名规则：只能包含数字、字母、下划线、小圆点，但不能用数字开头，不能是关键字或保留字com.公司名.项目名.业务模块名

import java.util.Scanner//表示只会引入java.util包下的Scanner

import java.util.*  //表示将java.util包下的所有类都引入

建议：使用哪个类就引入哪个类即可，不建议使用*导入

17、继承

 子类继承了所有的属性和方法，非私有的属性和方法可以在子类直接访问，但是私有属性和方法不能在子类直接访问，要通过父类提供公共的方法去访问。

当创建子类时，不管使用子类的哪个构造器，默认情况下总会调用父类的无参构造器，如果父类没有提供无参构造器，则必须在子类的构造器中用super去指定使用父类的哪个构造器完成对父类的初始化工作，否则，编译不会通过。

如果需要指定调用父类的某个构造器，则显式调用一下：super（参数列表），不写或者参数列表没有参数将默认调用无参构造器

super（）在使用时，必须放在构造器的第一行

super（）和this（）都只能放在构造器的第一行，因此两个方法不能共存在一个构造器

java所有类都是Object类的子类，Object是所有类的基类

父类构造器调用不限于直接父类，将一直往上追溯直到Object类(顶级父类)

18、super关键字

super代表父类的引用，用于访问父类的属性、方法、构造器

可以访问父类的属性，但不能访问父类的私有属性，可以访问父类的方法，但不能访问父类的私有方法

super遵循就近原则

19、方法重写

        子类的方法的形参列表，方法名称，要和父类方法的形参列表，方法名称完全一样

        子类方法的返回类型和父类方法返回类型一样，或者是父类返回类型的子类

            比如：父类返回类型是Object，子类方法的返回类型是String

        子类方法不能缩小父类方法的访问权限，public>protected>默认>private

20、多态

        方法的多态：重写和重载就体现多态

        对象的多态（核心）：

                一个对象的编译类型和运行类型可以不一致

                编译类型在定义对象时，就确定了，不能改变

                运行类型是可以变化的

                编译类型看定义时 = 号的左边，运行类型看=号的右边

        向上转型：父类调用了子类的对象  语法：父类类型  引用名 = new 子类类型（）

        特点：编译类型看左边，运行类型看右边

                可以调用父类中的所有成员（需遵守访问权限）

                不能调用子类的特有成员

                最终运行效果看子类的具体实现

        向下转型： 语法：子类类型   引用名 = （子类类型）父类引用

                只能强转父类的引用，不能强转父类的对象

                要求父类的引用必须指向的是当前目标类型的对象

                当向下转型后，可以调用子类类型中所有的成员