继续学习Java

一、面向对象

        1.java是一种面向对象的高级程序语言。

        2.面向对象最重要的两个概念：类和对象

        （1）类：是描述相同事务的共同特征的抽象。

        （2）对象：是具体存在的实例，是真实的。

        在代码层面，必须现有类才能 创建出对象

        （3）定义类的格式：

        修饰符  class   类名{

                

                }

        注意：①类名的首字母应该大写，满足驼峰写法。

                ②一个java代码文件可以定义多个类，但是只能有一个类，是用public修饰的，而且public修饰的类名必须成为代码的文件名称。

        （4）类中的成分研究：（有且仅有五大成分）

        ①成员变量（Field：描述类和对象的属性信息的）

        ②成员方法（Method：描述类或者对象的行为信息的）

        ③构造器（Constructor：初始化一个类的对象并返回引用）

        ④代码块

        ⑤内部类

        注意：只要不是这五大成分放在类下就会报错。

        （5）构造器的复习：

        ①作用：初始化一个类的对象并返回引用

        格式：

                修饰符  类名  (形参){

                

                }

        构造器初始化对象的格式：

                类名  对象名称  =  new  构造器 ;

        注意：一个类默认会自带一个无参数构造器，即使不写它也存在，但是如果一个类它写了一个构造器，那么默认的无参数构造器就被覆盖了！

        3.this 关键字

        （1）作用：

                ①this代表了当前对象的引用

                ②this关键字可以用在实例方法和构造器中

                ③this用在方法中，谁调用了这个方法，this就代表谁

                ④this用在构造器，代表了构造器正在初始化的那个对象的引用

        4.封装

        （1）封装的作用：

        ①可以提高安全性

        ②可以实现代码的组件化

        （2）封装的规范：

        ①建议成员变量都私有：用private修饰。

                private修饰的方法，成员变量，构造器等只能在本类被直接访问。

        ②提供成套的getter+setter方法暴露成员变量的取值和赋值。

                public 修饰符，是公开的意思

        小结：

                封装的核心思想：合理隐藏，合理暴露

        5.static 关键字的概述

        ①Java是通过成员变量是否有static修饰来区分是类的还是属于对象的。

        ②static == 静态 == 修饰的成员（方法和成员变量）属于类本身的。

        ③按照有无static修饰，成员变量和方法可以分为：

        成员变量：

        a.静态成员变量(类变量)：有static修饰的成员变量称为静态成员变量也叫类变量，属于类本身的，直接用类名访问即可。

        b.实例成员变量：无static修饰的成员变量称为实例成员变量，属于类的每个对象的，必须用类的对象来访问。

        成员方法：

        a.静态方法：有static修饰的成员方法称为静态方法，属于类本身的，直接用类名访问即可。

        b.实例方法：无static修饰的成员方法称为实例方法，属于类的每个对象的，必须用类的对象来访问。

        小结：

        成员变量有两种：

        a.有static修饰的属于类叫静态成员变量，与类一起加载一次，直接用类名调用即可。

        b.无static修饰的属于类的每个对象的叫实例成员变量，与类的对象一起加载， 对象有多少个，实例成员变量就加载多少份，必须用类的对象调用。

        成员方法有两种：

        a.有static修饰的属于类的叫静态方法，直接用类名调用即可。

        b.无static修饰的属于类的每个对象的叫实例方法 ，必须用类的对象调用。

               

      6.  

        7.继承：

        （1）继承是java中一般到特殊的关系，是一种子类到父类的关系。

        （2）继承的作用：可以提高代码的复用，相同代码可以定义在父类当中，然后子类直接继承父类，就可以直接使用父类的这些代码了。

        （3）继承的特点：子类继承了一个父类，子类就可以直接得到父类的属性（成员变量）和行为（方法）了

        （4）继承的格式：

                子类  extends  父类 {

                }

        （5）小结：

                ①继承是子类到父类的一种关系

                ②子类继承了一个父类，子类就可以直接得到父类的属性和行为了

                ③在java中继承是“ is   a  ”的关系。Cat  extends  Animal ：猫是一个动物

               ④在java中，子类是更强大的，子类不仅继承了父类的功能，自己还可以定义自己的功能

         

         （6）继承后成员变量的访问特点： 

        就近原则：子类有就找子类，子类没有找父类，父类没有就报错。        

        小结：this 代表了当前对象的引用，可以用于访问当前子类对象的成员变量。

                   super代表了父类对象的引用，可以用于访问父类中的成员变量。

        

        （7）继承后成员方法的访问特点： 

         就近原则：子类有就找子类，子类没有找父类，父类没有就报错。        

        小结：子类对象会优先使用子类的方法。

        8.方法重写

        （1）概念：子类继承了父类，子类就得到了父类的某个方法，但是子类觉得父类的这个方法不满足需求，子类就重写了一个与父类申明一样的方法来覆盖父类的该方法，子类的这个方法就进行了方法重写。

        （2）方法重写的校验注解：@Override  ，方法一旦加了这个注解，那就必须是成功重写父类的方法，否则报错。

        （3）方法重写的具体要求：

        ①子类重写方法的名称和形参列表必须与父类被重写方法一样。

        ②子类重写方法的返回值类型申明要么与父类一样，要么比父类返回值类型范围更小。       

        ③子类重写方法的修饰符权限应该与父类被重写方法的修饰符权限相同或者更大。       

        ④子类重写方法申明抛出得到异常应该与被父类重写方法申明抛出的异常一样或者范围更小

        （4）方法重写的规范：

        ①加上@Override注解

        ②建议“申明不变，重新实现”

        （5）小结：        

                方法重写是子类重写一个与父类申明一样的方法覆盖父类的方法

                方法重写建议加上@Override注解

                方法重写的核心要求：方法名称形参列表必须与被重写方法一致

                建议“申明不变，重新实现”

        （6）另外，静态方法和私有方法都不可以被重写。

        9.继承后构造器的特点

        特点：子类的全部构造默认一定会先访问父类的无参数构造器，再执行自己的构造器

        因为，子类的构造器的第一行默认有一个super( )调用父类的无参数构造器，写不写都存在。子类继承父类，子类就得到了父类的属性和行为。当我们调用子类的构造器初始化对象数据的时候，必须先调用父类构造器初始化继承自父类的属性和行为

        10.super调用父类构造器

        super( ... )：可以根据参数选择调用父类的某个构造器

        小结：可以在子类构造器中通过super( ... )根据参数选择调用父类的构造器，以便调用父类构造器初始化继承自父类的数据。

        

                

        11.引用类型作为方法参数和返回值

        引用类型作为java的数据类型，自然可以作为方法的参数类型和返回值类型。

        除了基本数据类型都是引用类型。

        12.抽象类

        （1）抽象类定义：父类知道子类一定要完成某个功能，但是每个子类完成的情况是不一样的，子类以后也只会用自己重写的功能，那么父类的该功能就可以定义成抽象方法，子类重写调用子类自己的方法。

        （2）抽象方法：没有方法体，只有方法签名，必须用abstract修饰。拥有抽象方法的类必须定义成抽象类。      

        （3）抽象类的作用：为了被子类继承。        

        （4）小结：抽象类是为了被子类继承，约束子类要重写抽象方法。

                注意：一个类继承了抽象类，必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类。

        （5）抽象类的特征：有得有失

        有得：抽象类得到了拥有抽象方法的能力。

        有失：抽象类失去了创建对象的能力（抽象类不能创建对象）

        （6）抽象类是否有构造器，抽象类是否可以创建对象，为什么？

        

         （7）抽象类存在的意义

        ①抽象类的核心意义就是为了被子类继承（就是为了派生子类，=）否则抽象类毫无意义！

        ②抽象类体现的是模板思想，部分实现，部分抽象，可以设计模板设计模式

        （8）什么是设计模式？

        

         （9）抽象类的注意事项和总结

        

       

13.接口

        （1）接口的概述：接口是更加彻底的抽象，在JDK1.8之前接口只能是抽象方法和常量。接口体现的是规范思想，实现接口的子类必须重写完接口的全部抽象方法。

        （2）接口的定义格式：

        修饰符  interface  接口名称{

        //在JDK1.8之前接口只能是抽象方法和常量

        }

        （3）接口的基本实现：

        ①子类  继承  父类

            实现类  实现  接口 

        ②类与类是继承关系，类与接口是实现关系，接口是被类实现的，实现接口的类称为：实现类

        类实现接口的格式：

        修饰符  class  实现类名称  implements  接口1，接口2，接口3，接口4，....{

        

        } 

        implements：类实现接口的关键字。

         （4）

        ①类与类是单继承关系，一个类只能继承一个直接父类

        ②类与接口是多实现关系，一个类可以同时实现多个接口

        ③接口与接口是多继承关系，一个接口可以同时继承多个接口

     

 14.静态代码块

        格式：

        static{

        }

        必须用static修饰，属于类，会与类一起优先加载，而且自动触发执行一次。

        静态代码块可以用于执行类的方法之前进行静态资源的初始化操作。

15.final关键字

（1）final修饰类：类不能被继承了。

（2）final修饰方法：方法不能被重写。

（3）final修饰变量，变量有且仅能被赋值一次。

        

16.单例设计模式

        （1）单例：单例的意思是一个类永远只存在一个对象，不能创建多个对象。

        （2）为什么要用单例？

        ①开发中有很多类的对象我们只需要一个，例如虚拟机对象！任务管理器对象！

        ②对象越多越占内存，有些时候只需要一个对象就可以实现业务，单例可以节约内存，提高性能！

        （3）如何实现单例

        ①饿汉单例模式：

        通过类获取单例对象的时候，对象已经提前做好了

        实现步骤：

                1.定义一个单例类。

                2.把类的构造器私有。

                3.定义一个静态成员变量用于储存一个对象（饿汉单例在返回对象的时候，对象要已经做好，所以这里直接创建出来）

                4.定义一个方法返回单例对象。

        ②懒汉单例模式：

        通过类获取单例对象的时候发现没有对象才会去创建一个对象

          实现步骤：

                1.定义一个单例类。

                2.把类的构造器私有。

                3.定义一个静态成员变量用于储存一个对象（懒汉单例不能直接创建对象，必须需要的时候才创建）

                4.定义一个方法返回单例对象，判断对象不存在才创建一次， 存在直接返回。

17.枚举类

        （1）格式

        修饰符  enum  枚举名称{

        实例1名称，实例2名称 ... ；

        }

        枚举类第一行罗列的必须是枚举类的对象名称

        （2）枚举类特点

        ①枚举类是fina修饰的，不能被继承。

        ②枚举类默认继承了枚举类型：java.lang.Enum

        ③枚举类的第一行罗列的是枚举类的对象。而且是用常量存储的。

        ④所以枚举类的第一行写的都是常量名称，默认存储了枚举对象

        ⑤枚举类的构造器默认是私有的

        ⑥枚举类相当于是多例设计模式

         （3）

 18.多态

        （1）多态的形式：

        父类类型  对象名称  =  new  子类构造器；

        接口  对象名称  =  new  实现类构造器；

         （2）多态的概念：

        同一个类型的对象，执行同一个行为，在不同的状态下会表现出不同的行为特征。

        （3）多态的识别技巧

        对于方法的调用：编译看左边，运行看右边。

        对于变量的调用，编译看左边，运行看左边。

        （4）多态的使用前提：

        ①必须存在继承或者实现关系。

        ②必须存在父类类型的变量引用子类类型的对象。

        ③需要存在方法重写。

        （5）多态的优劣势：

       优势： ①在多态形式下，右边对象可以实现组件化切换，业务功能也随之改变，便于扩展和维护。

        ②实际开发的过程中，父类类型作为方法形式参数，传递子类对象给方法，可以传入一切子类对象进行方法的调用，更能体现出多态的扩展性和便利。

        劣势：多态形式下，不能直接调用子类特有的功能，编译看左边！左边父类中没有子类特有的功能，所以代码在编译阶段就直接报错了。

 

19.匿名内部类

        （1）匿名内部类就是一个没有名字的局部内部类，匿名内部类可以简化代码。

        （2）匿名内部类的格式：

                new  类名/抽象类/接口 ( 形参 ) {

                方法重写。

        }

        （3）匿名内部类的特点：

        ①匿名内部类是一个没有名字的内部类

        ②匿名内部类一旦写出来，就会立即创建一个匿名内部类的对象返回

        ③匿名内部类的对象的类型相当于是当前new的那个的类型的子类类型

20.

        

 21. toString( )

        toString() 默认是返回当前对象在堆内存中的地址信息：开发中输出对象变量，更多的时候是希望看到对象的内容数据而不是对象的地址信息！所以父类toString()方法存在的意思就是为了被子类重写，重写toString可以看到对象的内容信息。

22.泛型

        （1）泛型就是一个标签：<数据类型>，泛型和集合都只能支持引用数据类型，不支持基本数据类型。

        （2）泛型类的概念：使用了泛型定义的类就是泛型类

        泛型类的格式：

                修饰符  class  类名<泛型变量>{

        

        }

        泛型变量建议使用E,KT,V，但是是在定义泛型的时候使用

        泛型类的核心思想：是把出现泛型变量的地方全部替换成传输的真实数据类型。        

        （3）泛型方法：定义了 泛型的方法就是泛型方法

        泛型方法的定义格式：

        修饰符  <泛型变量>  返回值类型  方法名称(形参列表 ){

        }

        注意方法定义了什么泛型变量，后面就只能用什么泛型变量。

        （4）泛型接口：使用了泛型定义的接口就是泛型接口

        泛型接口的格式：

        修饰符  interface  接口名称<泛型变量>{ 

        }

        （5）通配符： ？

                ？可以用在使用泛型的时候代表一切类型

                E,T,K,V 是在定义泛型的时候使用代表一切类型

                泛型的上下限：

                

22.集合

        （1）集合是一个大小可变的容器，容器中的每个数据称为一个元素，数据==元素，集合的特点是：类型可以不确定，大小不固定。

        （2）数组：类型和长度一旦定义出来就都固定了

        （3）

 

小结：Collection是集合的祖宗类，Collection集合的功能是一切集合都可以使用的。 

        （4）常用API：

        

         （5）迭代器（针对collection集合的遍历）

        ① Iterator( )遍历

         ②foreach(增强for循环)遍历

        缺点是foreach遍历无法知道遍历到了那个元素，因为没有索引。

        （6）常见的数据结构种类

        ①数据结构指的是数据以什么方式组织在一起，不同的数据结构，增删改的性能是不一样的，不同的集合底层会采用不同的数据结构。

        ②数据存储的常用结构有：栈，队列，数组，链表和红黑树

a、栈：后进先出，先进后出。例如手枪弹夹

b、数组：元素存在索引，特点是查询元素快（根据索引快速计算出元素的地址，然后立即去定义），增删元素慢（创建新数据，迁移元素）

c、链表：元素不是内存中的连续区域，元素是游离存储的，每个元素会记录下个元素的地址，特点是查询元素慢，增删元素快

        （7）红黑树

        

        （8）ArrayList集合

         （9）List集合遍历方式：

        

         （10）LinkedList集合的使用

 另外：如果查询多而增删少用ArrayList集合，如果查询少而增删首尾较多用LinkedList集合。

        （11）set集合

set集合添加的元素是不重复的，是如何去重复的？