java学习笔记

1、（short，byte）和char之间不能之间转换
2、byte、short、char，他们三者之间可以计算，在计算时
首先转换为int类型
3.字符串转基本数据类型
String str="123";
int n1=Integer.parseInt(str);
4.运算符：instanceof 检查是否是类的对象
5.java保留字：
现有Java版本尚未使用，但以后版本可能会作为关键字使用。
自己命名标识符时要避免使用这些保留关键字。
byValue、cast、future、generic、inner、poerator、outer
rest、var、goto、const
6.Scanner类 表示简单文本扫描器，在java.util包
      1.引入/导入Scanner类所在的包
      2.创建Scanner对象，new创建一个对象
      myScanner就是Scanner类的对象
      3.接收用户输入了，使用相关的方法
Scanner myScanner=new Scanner （System.in）;
String name=myScanner.next();直接默认Sting类型
int age=myScanner.nextInt();//接收用户输入int
7.按位取反操作~a
8.数组的定义
double []a={1,2,2};中括号位置这样可以
double a[]={1,2,2};中括号位置这样也可以,都行
int a[]=new int[5];
我们可以通过   数组名.length    得到数组的大小/长度
9.使用OOP面向对象解决
实例化一只猫【创建一只猫对象】
1.new Cat（）创建一只猫
Cat cat1=new Cat（）；
10.成员变量=属性=field（字段）
即  成员变量是用来表示属性的，授课中，统一叫属性
11.创建person对象
p1是对象名（对象引用）
new person（）创建的对象空间（数据）才是真正的对象
person p1=new person（）；
12.属性如果不赋值，有默认值，规则和数组一样。具体说：
int 0,short 0,byte 0,long 0,float 0.0,double 0.0,char \u0000,
boolean false,String null
13.二维数组的遍历
for(int i=0;i< arr.length;i++){//遍历二维数组的每个元素  
for(int j=0;j<arr[i].length;j++){//arr[i].length 得到对应的每个一维数组的长度
}
}
14.构造器/构造方法
构造方法又叫构造器，是类的一种特殊的方法，它的主要作用是完成
对新对象的初始化。它有几个特点：
     1）方法名和类名相同
     2）没有返回值
     3）在创建对象时，系统会自动的调用该类的构造器完成对
          对象的初始化
15.有构造器创建对象：
person p1=new person（”king“，40）；
无构造器创建对象：
Dog dog1=new Dog（）；
class Dog{
//如果程序员没有定义构造器系统，系统会自动给类生成一个默认的无参构造器（也叫默认构造器）
默认构造器
Dog（）{

}
}
16.对象创建流程分析   person p=new person（“习防御”，20）；
 1）加载person类信息（person.class），只会加载一次
 2)在堆中分配空间（地址）
 3）完成对象初始化      1，默认初始化 2，显式初始化  3，构造器初始化
 4）把对象在堆中的地址返回给p（p是对象名，也可以理解成是对象的引用
17.this关键字
哪个对象调用，this就代表哪个对象
18.访问构造器语法：this（参数列表）//必须放在第一条语句（该语法只能在构造器中使用，即只能
在构造器中访问另外一个构造器），该方法不能在类定义的外部使用，只能在类定义的方法中使用
this不受就近变量的影响，它始终定位到本类的属性
19.compareTo比较方法（this练习）
this.name.equals(p.name) //代表本类的名字和p的名字相同，用equals是因为String是引用
==比地址所以用equals，比较名字和年龄的方法不同
Integer , String，Date，file四个类的比较都是用equals
this.age==p.age//代表本类的年龄和p的年龄相同
20.包的命名
只能包含数字 字母 下划线 小圆点，但不能用数字开头，不能是关键字或保留字
命名规范：一般是小写字母+小圆点一般是
com.公司名.项目名.业务模板块名    比如:com.sina.crm.user //用户模块
21.Java常用的包为
java.lang.*  lang包是基本包,默认引入,不需要再引入
java.util.*    util包,系统提供的工具包,工具类,使用Scanner
java.net.*  网络包,网络开发
java.awt.*    是做java的界面开发,GUI 
22.package:作用是声明当前类所在的包,需要放在类的最上面,一个类中
最多只有一句package
import:位置放在package的下面,在类的定义前面,可以有多句且没有顺序要求
import就是引入包的作用
23.访问修饰符:
Java提供四种访问控制修饰符号,用于控制方法和属性(成员变量)的访问权限(范围):
公开级别:用public修饰,对外公开
受保护级别:用protected修饰,对子类和同一个包中的类公开
默认级别:没有修饰符号,向同一个包的类公开
私有级别:用private修饰,只有类本身可以访问,不对外公开
24.面对对象编程三大特征:封装   继承  多态
25.继承：子类必须调用父类的构造器，完成父类的初始化
当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参
构造器，如果父类没有提供无参构造器，则必须在子类的构造器中用super去指定使用
父类的哪个构造器完成对父类的初始化工作，否则，编译不会通过。
26.如果希望指定去调用父类的某个构造器，则显示的调用为：super（参数列表）
super在使用时，必须放在构造器第一行
super（）和this（）都只能放在构造器第一行，因此这两个方法不能共存在一个构造器
可以让构造器调用默认的super（），再自己在第一行写this（）
27.父类构造器的调用不限于直接父类，将一直往上追溯直到顶级父类
28.只要是构造器就有super（）如果是有参构造器，super（）；会被隐藏
29.super代表父类的引用，用于访问父类的属性  方法   构造器，不能访问父类的private
30.方法重写/覆盖：
方法覆盖（重写）就是子类有一个方法，和父类的莫一个方法的名称、返回类型、参数一样
，那么我们就说子类的这个方法覆盖了父类的方法
子类方法的返回类型和父类方法返回类型一样，或者是父类返回类型的子类
比如父类的返回类型是Object，子类返回类型是String
子类方法不能缩小父类方法的访问权限
总而言之：父类大于子类
31.多态提高代码复用性
方法重载体现多态
方法重写也体现多态
32.多态的具体表现：
下面的是对象的多态：
一个对象的编译类型和运行类型可以不一致
编译类型在定义对象时，就确定了，不能改变
运行类型是可以变化的
编译类型看定义是 = 号的左边，运行类型看  =  号的右边，右边new谁，父类就调用谁的方法
34.多态就是多种状态
对象或方法具有多种形态。是面向对象的第三大特征，多态是建立在封装和继承基础
之上的
35.我们通过不同的参数个数去调用sum方法，就会去调用不同的方法
因此对sum的方法来说，就是多种状态的体现，重载就体现了多态
36.方法的多态     对象的多态
37.对象的多态
Animal animal=new Dog();
animal.cry();
其中Dog是animal的子类
animal编译类型就是Aniaml，运行类型是Dog，所以cry就是Dog的cry
38.多态的前提是：两个对象（类）存在继承关系
多态的向上转型
本质：父类的引用指向了子类的对象（向上转型）
语法：父类类型     引用名   =   new    子类类型（）；
特点：编译类型看左边，运行类型看右边。可以调用父类中的所有成员（需遵守访问权限）
不能调用子类中特有成员
最终运行效果看子类的具体表现
39.向上转型：父类的引用指向了子类的对象
可以调用父类中的所有成员（需遵守访问权限）
但是不能调用子类的特有的成员
因为在编译阶段，能调用哪些成员，是由编译类型来决定
40.左父右子是多态
41.多态的向下转型
语法：子类类型    引用名  =（子类类型）  父类引用名；
只能强制转换父类的引用，不能强制转父类的对象
要求父类的引用必须指向的是当前目标类型的对象
向下转型后，可以调用子类类型中所有的成员
先有上转型再有下转型 
Cat cat = （Cat）anmal；
cat的编译类型是Cat，运行类型是Cat
原来的animal指向猫但不仅仅指向猫，所以不能调用猫的特有方法
42.属性重写：属性没有重写之说，属性的值看编译类型
43.instanceOf  比较操作符，用于判断对象的运行类型是否为xx类型xx类型的子类型
44.java的动态绑定机制：
当调用对象方法的时候，该方法会和该对象的内存地址/运行类型绑定
当调用对象属性时，没有动态绑定机制，哪里声明，哪里使用 
45.==  ：既可以判断基本类型，又可以判断引用类型。
如果判断基本类型，判断的是值是否相等。
如果判断引用类型，判断的是地址是否相等，即判定是不是同一个对象
46.equals  :是Object类中的方法,只能判断引用类型
47.finalize方法
当对象被回收时，系统自动调用该对象的finalize方法。子类可以重写该方法，
做一些释放资源的操作
什么时候被回收：当某个对象没有任何引用时，则jvm就认为这个对象是一个垃圾对象，
就会使用垃圾回收机制来销毁该对象，在销毁对象前，会先调用finalize方法
垃圾回收机制的调用，是由系统来决定（即有自己的GC算法），也可以通过System.gc（）
主动触发垃圾回收机制        保洁员案例
我们在实际开发中，几乎不会运用该方法
48.类变量（静态变量）static静态
static变量是同一个类所有对象共享
static类变量，在类加载的时候就生成了
49.类方法（静态方法）
形式如下：
访问修饰符  static 数据返回类型  方法名（）{  }    //推荐
static   访问修饰符  数据返回类型  方法名（）{ }
类方法的调用：
使用方法：类名.类方法名  或则  对象名.类方法名（前提是满足访问修饰符的访问权限和范围）
50.类方法和普通方法都是随着类的加载而加载，将结构信息存储在方法区：
    类方法中无this的参数
   普通方法中隐含着this的参数
   类方法可以通过类名调用，也可以通过对象名调用
    普通方法和对象有关，需要通过对象名调用，比如对象名.方法名(参数),不能通过类名调用
     类方法中不允许使用和对象有关的关键字,比如this和super  普通方法(成员方法)可以(因为this
      和super与对象绑定,所以得先创建对象
    
     类方法中只能访问静态变量或静态方法
      普通成员方法,既可以访问普通变量(方法),也可以访问静态变量(方法)
51.非静态方法,不能通过类名调用,需要先创建对象再调用,静态方法可以通过类名调用
52.public static void main(String []args){}:
      1.main方法由虚拟机调用
      2.Java虚拟机需要调用类的main()方法,所以该方法的访问权限必须是public
       3.java虚拟机在执行main()方法时不必创建对象,所以该方法必须是static
      4.该方法接收String类型的数组参数,该数组中保存执行java命令时传递给所运行
          的类的参数
         5.java执行的程序  参数1 参数2 参数3
53.代码块:
  代码块又称初始化块,属于类中的成员[即是类的一部分],类似于方法,将逻辑语句封装在方法体中,
  通过{}包围起来
  但和方法不同,没有方法名,没有返回,没有参数,只有方法体,而且不用通过对象或类显式调用,
   而是加载类时,或创建对象时隐式调用
   基本语法:
[修饰符]{ 
    代码
};
说明注意:
修饰符可选,要写的话,也只能写static
代码块分为两类,使用static修饰的叫静态代码块,没有static修饰的,叫普通代码块(非静态代码块)
逻辑语句可以为任何逻辑语句(输入  输出   方法调用   循环   判断等)
;号可以写上,也可以省略

代码块的好处:
相当于另外一种形式的构造器(对构造器的补充机制),可以做初始化的操作
如果多个构造器中都有重复的语句,可以抽取奥初始化块中,提高代码的重用性
代码块的快速入门
54.代码块2.0
三个构造器->重载
三个构造器都有相同的语句
这样代码看起来比较冗余
这时我们就可以把相同的语句放到同一个代码块中
这样当我们不管调用哪个构造器,创建对象,都会先调用代码块的内容
代码块调用的顺序优先于构造器
class movie{
private String name;
private doble price;
private String director;
    {
        System.out.println("abc");
        System.out.println("qwe");
        System.out.println("123");
    }
public movie(String name){
    System.out.println("asdfsd");
    this.name = name;
}
//然后还有两个构造器,我就省略了
}
55.代码块3.0
static代码块也叫静态代码块,作用就是对类进行初始化,而且它随着类的加载而执行,并且只会
执行一次.如果是普通代码块,每创建一个对象,就执行

类什么时候被加载(代码块什么时候被执行):
  1.创建对象实例时(new)
  2.创建子类对象实例,父类也会被加载
  3.使用类的静态成员时(静态属性 ,静态方法)

  普通的代码块,在创建对象实例时,会被隐式的调用.被创建一次,就会被调用一次
   如果只是使用类的静态成员时,普通代码并不会执行
56.
创建一个对象时，在一个类调用顺序是：
代码块的执行：静态按顺序执行，普通按顺序执行，静态优先于普通，构造器最后执行
57.构造器的最前面其实隐含了super（）和调用普通代码块，静态相关的代码块，属性初始化，
在类加载时，就执行完毕，因此是优先于构造器和普通代码块执行
class A{
   public A{
//这里有隐藏的执行要求
//（1）super（）：
//（2）调用普通代码块
System.out.println("ok");
    }
}
58.创建一个子类对象时（继承关系），他们的静态代码块，静态属性初始化，普通代码块，
普通属性初始化，构造方法的调用顺序如下：
1）父类的静态代码块和静态属性（优先级一样，按定义顺序执行）
2）子类的静态代码块和静态属性（优先级一样，按定义顺序执行）
3）父类的普通代码块和普通属性初始化（优先级一样，按定义执行）
4）父类的构造方法
5）子类的普通代码块和普通属性初始化一样（优先级一样，按定义顺序执行）
6）子类的构造方法
7）静态代码块只能直接调用静态成员（静态属性和静态方法），普通代码块可以调用任意成员
59.抽象类：
所谓抽象方法就是没有实现的方法，所谓没有实现就是指没有方法体，当一个类中存在抽象方法
时，需要将该类声明为abstract类
一般来说，抽象类会被继承，由其子类来实现抽象方法
60.抽象类的介绍：
1）用abstract关键字来修饰一个类时，这个类就叫抽象类
访问修饰符 abstract 类名{
}
2）用abstract关键字来修饰一个方法时，这个方法就是抽象方法
访问修饰符 abstract 返回类型 方法名 （参数列表）；//没有方法体
3）抽象类的价值更多作用是在于设计，是设计者设计好后，让子类继承并实现
抽象类（）
4）抽象类，是考官比较爱问的知识点，在框架和设计模式使用较多
5）抽象类可以有任意成员（抽象类本质还是类），比如：非抽象方法  构造器  静态属性等等
6）抽象方法不能有主题，即不能实现
7）如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类
8）抽象方法不能使用private  final 和static来修饰，因为这些关键字都是和重写相违背的（抽象方法最终
       要被子类重写或实现）
61.抽象类不能被实例化
比如：
abstract class A{
}
new A（）；//这是错误的
62.接口
基本介绍：
接口就是给出一些没有实现的方法，封装到一起，某个类要使用的时候，再根据具体情况把这些方法写出来
语法：
interface 接口名{
//属性
//方法
}

class 类名 implements 接口{
    自己属性；
    自己方法（1.抽象方法 2.默认实现方法 3.静态方法）；
    必须实现的接口的抽象方法
}
在jdk7.0前 接口里的所有方法都没有方法体，即都是抽象方法
jdk8.0后（包括jdk8.0）接口类可以有静态方法，默认方法，也就是说接口中可以有方法的具体实现
在jdk8后，可以有默认实现方法，但是需要使用default关键字修饰、
公司基本上用jdk8或jdk11，基本上没人用jdk7
在接口中，抽象方法，可以省略abstract关键字
63.
   1）接口不能被实例化
    2）接口中 所有的方法是public方法，接口中抽象方法，可以不用abstract修饰   例子如下：
     void  aaa（）；
      实际上是    abstract void  aaa（）；

    3） 一个普通类实现接口，就必须将该接口的所有方法都实现，可以使用alt+回车来解决
     4）抽象类实现接口，可以不用实现接口的方法
    5）一个类同时可以实现多个接口
    6）接口中的属性，只能是final的，而且是public static fianl 修饰符。比如：
   int a=1；实际是public static final int a=1；
    7）接口中属性的访问形式：接口名.属性名
     8）一个接口不能继承其他的类，但是可以继承多个别的接口
      9）接口的修饰符只能是public 和默认，这点和类的修饰符是一样的
64.接口的多态
    USB接口案例，既可以接收手机对象，又可以接收相机对象，就体现了接口多态（接口类型的变量可以指向
    实现了接口的类的对象）
65.多态数组->接口类型数组
Usb[] usbs=new Usb[2];
usb[0]=new phone();
usb[1]=new camera();  
66.多态传递
接口类型的变量可以指向，实现了该接口的类的对象
如果IG继承了IH接口，而teacher类实现了IG接口
那么，实际上就相当于teacher类也实现了IH接口
67.内部类
局部内部类：定义在方法中/代码块中
68.三个基本的Annotation：
1）@Override：限定某个方法，是重写父类方法，该注解只能用于方法
2）@Deprecated：用于表示某个程序元素（类   方法 等）已过时
3）SuppressWarnings：抑制编译器警告
69.向上转型   向下转型
A  b=new  B( );//向上转型
B   b2=new  (B)b;//向下转型
class A{ };
class B extends A{ }

===================================================================
1.异常处理：
将该代码块选中—>快捷键ctrl+alt+t->选中try—catch
try->catch->finally：
          程序员在代码中捕获发生的异常，自行处理
try{
代码可能出现的异常
}catch(Exception e){
      1）当异常发生时
      2）系统将异常封装成Exception对象e，传递给catch
      3）得到异常对象后，程序员，自己处理
        4）注意：如果没有发生异常
            catch代码块不执行
}
finally{
         1）不管try代码块是否有异常发生，始终要执行finally
           2）所以，通常将释放资源的代码放在finally
}

throws：
将发生的异常抛出，交给调用者（方法）来处理，最顶级的处理者就是JVM

try-catch-finally 和throws二选一
如果程序员没有显示是处理异常，默认throws

可以try-catch
可以try-finally   //这种用法相当于没有捕获异常，因此程序会崩
可以try-catch-finally

throw和throws的区别：
                           意义                                  位置              后面跟的东西
throws       异常处理的一种方式                方法声明处           异常类型
throw    手动生成异常对象的关键字           方法体中              异常对象