JavaSE学习笔记（1）

权限修饰符

        private 同一个类中可以使用（私有的）

        protected 用类、同包、子类  （其他包的子类也可以访问）（受保护的）

        public 所有包的所有类

        default 默认的 

        定义一个类中属性的方式

                1. set方法

                2. 有参构造器

        顶一个类最标准方式

                1.属性私有化

                2.提供 有/无参的构造

                3.提供get/set方法

Arrays工具类

Arrays.sort() 数组排序

int index = Arrays.binarySearch(arr,79); 查询数据（折半二分查找）第一个为要查询的数组、第二个为要查询的值

面向对象

属性都以成员变量体现、行为都以方法体现

定义具体对象：类名 变量名 = new 类名();

构造方法：用于初始化对象、名称与类名一致。构造方法中不能同时使用super和this调用方法。

按值传递：参为基本数据类型、按引传递：参为引用类型 (对象也能当参数进行传递)

this最常用的方法 (代表的是当前类的)

        区分成员变量、局部变量

        this不能使用在static方法中        

        使用this进行构造方法调用的时候，一定要放在代码的第一行

static修饰变量

        成员变量 static string name；如果是静态则会被所有对象共享，所使用的都是一个静态变量储存地点为 “方法区” 而不是 “堆内存”

static方法

        其他类调用时不用创建对象可以直接 “ 类名.方法名() " 来调用

        如果静态方法想用外面的变量，变量也必须是静态的 ( 成员变量 )

        非静态方法可以随意调用静态方法  

static代码块

        一般用于初始化成员静态变量的

        类加载进入内存后执行一次 ( 只执行一次 )

        系统形成class文件加载进入java虚拟机时（类加载）

        代码块的执行顺序为： 父静、子静、父普、父构、子普、子构

继承性

        当许多个子类需要用到同一个成员变量方法时。创建一个父类，而后子类继承即可( 实现代码的复用 )  eg： 父类：car   子类： Aodi、Benchi

        public void Aodi extends Car(){}、public void Benchi extends Car(){}

        子类可以直接调用父类的方法。 super.run()。 调用父类的run方法

多态性

        指的是同一方法调用，由于对象不同可能会有不同的行为：一个类具有多种形态 要求： 对象不同、实现方法不同

        public static void factory(Fu f){ f.eat(); }

        zi1 zi1 = new zi1();   、  zi2 zi2 = new zi2();   

        factory(zi1);    子类1   指定传入哪个子类方法 

        创建对象： Fu a = new zi1(); 在编译的时候会认为是父类对象 用父类表示子类对象。只能调用父类共同拥有的方法，不能使用子类单独声明的方法。

        向上转型： 用父类表示子类        Fu a = new zi1();

        向下转型：强转          zi1 z =(zi1)f；

枚举

        Enum（枚举类型）就是放一些常量  public enum Gender{   男，女   }

        定义构造函数的时候直接写枚举类型即可

                private Gender sex；

        get，set方法返回值类型 即 也是枚举类型        如何传值：

        创建对象 student stu = new student(Gender.男) 即可完成传值

 包装类

        可以提供更多的功能 且 实现字符串与基本数据类型的转换

        Integer b = new Ingeter(10)     包装类表示的整数据

        int i = Integer.parseInt(c)  把string 转为int  c代表的是字符串（string 是底层为final的 不可更开）        

接口（规范）

        强制----类似于抽象类的升级版（java不可多继承  但可多接口） interface。

        接口里的方法都是公开抽象的。  必须全部重写接口里定义的方法

        public class Zi inplements(实现) Fu(接口)

        接口和接口之间是实现关系，并且可以多实现

抽象方法和抽象类

       （定义一种规范） 抽象方法必须重写，abstract （抽象方法没有方法体）

        eg： public abstract void aa();      即  子类必须重写aa方法

        抽象方法 只能由抽象类写。普通类无法写抽象方法。

        抽象类不可以被实例化（不可以new对象）

String类的使用

        a.charAt(2) 返回指定字符的下标

        string类的concat是创建一个新的字符数组，存原来与新加入的（拼接）

StringBuffer JDK1.0提供 线程安全，做线程同步检查，效率较低

StringBuilder JDK1.5提供 线程不安全 不做线程同步检查 效率高 (用的频率较高)

        eg： StringBuilder builder = new StringBuilder("填写字符串")；

                        builder.append("sxt");  

                        builder.insert(3,"~~~"); 可以往指定的位置追加内容

                        builder.reverse();   反转，倒叙输出字符串

StringBuilder底层扩容机制（原有数组的长度 x 2 + 2）即为扩容后的长度

Date类（日期类）

        Date date = new Date(); 定义一个日期类

        d = "2019-10-9"  :  date = Date.valueof(d);  字符串转换为日期

        java.sql包下的Date（date只有年月日、Time 只有时分秒、Timestamp 既有年月日又有时分秒）

DateFormat类（一个抽象类。规定格式输出）

        Date date = new Date();

        DateFormat dateFormat = new SimpleDateFormat(yyyy年MM月dd日  hh(时):mm(分):ss(秒));

        String format = dateFormat.format(date); 规定格式输出当前年月日，时分秒

Math 类（皆为静态方法）

        Math.PI()   圆周率

        Matn.round()  四舍五入

        Math.sqrt() 开平方

        Math.pow() 几次幂

        Matn.Random()   产生0-1的随机数

Random类 （eg：0-9 随机整数）

        Random random = new Random();

        int i = random.nexInt(10);  产生0-10的随机整数（不包含10）

Object类（顶级父类）

        == 比的时基本数据类型

        a.equals(b) 比的是 a与b 引用类型的大小 （不考虑地址，比的是值）

        hashcode 类似于身份证  

        两个对象== 返回值为true  那么hashcode的值一定相同 但如果hashcode相同 ==的返回值却不一定是true

final

        final修饰变量，不可被改变，一旦有了初值后

        如果修饰方法   不可被子类重写，但可以被重载

        如果修饰类       不能被继承

异常处理

        一共两种处理方式

                1. tey-catch-finally 异常处理（手动处理）捕获异常ctrl+alt+T 可以快速书写异常处理等一系列命令

                        try{  (存放可能出错的代码块)
                            int a = 1010  (如果无措，cath不会运行)
                        }cath Exception{  (异常处理方案)
                            ("我是异常信息")    
                        }finally{
                            ~~~   (不管程序是否报错 finally内的代码都会正常执行)
                        }

                2. 抛出异常

                        public void aa() throws Exception{}

                        子类抛出的异常一定要比父类抛出的异常低  子 < 父

内部比较器 Comparable接口 

               CompareTo 比较字符串大小 （返回值为负则后面大，为正则前大）

                L1.CompareTo(L2);

外部比较器 Comparator接口

                int i = bj.compare(people,people2);

匿名内部类（也属于局部内部类）

                一个类里面只能放一个内部类（外边的用不了里边的，里面的可以用外面的）

                1.Fu f = new Fu(){  重写父类方法 }

                2.作用： 快速构建子类对象

                3.此内部类没有名字 所以不可定义构造函数，类中定义的变量在外无法赋值

                4.如真要赋值，可以采用普通代码块来进行操作