Java笔记 javaoop
程序员文章站
2022-06-07 08:41:38
...
学习Java编程两周，其中学习了面向对象，OOP思想。
学习面向对象，最重要的是OOP思想。它不像C语言是面向过程，程序员就像执行者一步一步的做。就像案例大象与冰箱。C语言的执行过程是：1、人打开冰箱。 2、人把大象放进冰箱。3、人把冰箱关上。而面向对象则像是管理员。看这个案例有几个对象：在这个案例中，有人、大象、冰箱三个对象。管理员只要知道这几个对象之间要做什么，而不用管它怎么做。
笔记：
1.sleep 休息几秒，再执行下一个语句。
2.生成0-n的整数
Random random = new Random;
int k = random.nextInt(n);
4.构造函数当类被实例化后立即调用的函数
继承----------------------------------------------
* 继承:其实就是2个类之间的关系,由子类去继承父类,然后可以使用父类的所有的属性以及行为.
* 继承的优点:
* 1、子类继承父类，可以使用父类的属性
* 2、子类继承父类，可以使用父类的函数
* 3、子类继承父类，但是如果子类有相同名字以及返回值和参数的函数，那就优先调用子类的，这叫做覆盖或者重写
* 4: 一旦父类有构造函数,那么会调用去调用父类的
* 5: 如果子类也有构造函数,会优先去调用父类的构造函数
*/
* super(); 主动去调用父类的构造函数
* 一旦子类继承父类在实例化后,默认加载super();也就是默认加载父类的构造函数
*/
* 继承注意事项：
* 1、继承：子类继承父类，使用父类属性和函数。
* 2、继承在java中，不能多继承，但不代表不能多重继承。
* 3、一旦发生多重继承，先使用父类的，如果父类没有，使用父类的父类的。
* 4、超类和基类一般表示就是最开始的类，祖宗。
*
* 关联(普通朋友)、聚合(好朋友)、组合(基本一起死)
*
* 关联：一般是指 A类 和 B类只是一种普通的关系约束，例如：行为之间相互使用，但是并不影响各自的情况
* 聚合：一般是指 A类和B类，是一种整体与个体的关系，如：汽车和*的关系，但是少了*，它还叫汽车。
* 组合:一般是指 A类和B类，有一种与生俱来的关系，也就是刚开始2个对象就已经存在，一旦一个发生意外，那么另一个也即将销毁。
* final: 也是一种修饰符。可以作用于：函数、变量、类.
* final作用于类的时候，一般表示该类没有子类的情况下使用。
* 一旦作用于类，就不能就被继承。如：final class Person(){}
*
* final作用于函数的时候.那么这个函数就不能被子类重写。
* 如： final void run(){}
*
* final作用于变量的时候，一般说明这个变量只能赋值一次，一旦赋值就不能再改了。
* 如： final int a = 10; //在java中，一般这种表现形式为常量。
* final 的命名方式有所讲究：一般为 final int A = 10; final float P_I = 10f;
抽象-----------------------------------
* 抽象(abstract)：修饰符的一种
* 抽象也可以修饰类，方法
*
** 1、抽象类里可有抽象方法。
** 2、一旦定义了抽象方法，那么其子类必然需要实现父类的抽象方法。
**3、抽象类中的所有的抽象方法，在子类中都必须实现
** 4、抽象方法一定被定义，那么肯定这个类也是抽象类。 抽象类里可以没有抽象方法但是抽象方法必须在抽象类里。
**5、抽象方法本身不负责具体实现，由其子类负责具体实现。
** 6、抽象类本身不能被实例化。
** 7、abstract不能与final在一起，因为final是没有子类的，而abstract往往作用于父类，所以不能一起修饰
** 8、abstract不能与static与private在一起。
**9、抽象一般用于申明一些固定的方法，具体实现需要到子类
接口------------------------------------
*
* 接口：接口就是一组规范
* 接口：就是一旦遵守这组规范，你就必须要实现这些行为。
* 接口：一般与implements搭配使用，一个是接口，一个是实现。
* 接口：用的是interface关键字。
* interface 接口名{
* 属性 / 行为
* }
* 在interface内部每个属性都默认添加：
* public static final int PI = 1
* 如果没有，那是系统默认添加
* 在interface内部每个函数都会加public
* public void run()
*
* 因此，在接口中，所有的属性与函数都需要加public
* 因为，这些接口里的行为都需要实现。
*
* 在某种层次理解，接口就是加强版抽象。因为：
* 1、抽象类里不需要一定要有抽象函数。因此继承抽象，不需要一定实现非抽象方法。
* 2、但是接口一旦实现，那接口内部所有的函数，都需要都实现。
* 3、因此就相当于在抽象类内部，所有的属性都是final属性，所有函数都是抽象函数。
* 抽象与接口的区别：
* 1、抽象作用于类，一般都会有子类。
* 2、接口一般作用于函数。
* 3、抽象类只能单继承。接口也多实现,也能多继承(不推荐)。
* 4、抽象可以有方法体，但是接口没有。
* 5、实现接口必须要加入修饰符 public
*
* 为什么要有接口？
* 1、接口就是规范，定义实现这个事物标准
* 2、如果多个类去实现同一个接口里的方法(而不去写接口的话)，
* 是不知道这些行为属于同一类型的。
* 3、统一标准的目的就是为了让所有事物知道这个是“做什么”
但是具体不用知道“怎么做”
*
多态------------------------------------------------------
多态的前提：
*1、肯定会有继承。
*2、肯定会有重写
*3、肯定是父类去表示子类
多态的好处：
1、多种多态表示一个对象
2、当使用父类的形态表示子类的行为的时候，是可以减少代码冗余的。
3、多态有很好的可扩展性
* 多态的特性(非静态函数)：
* 1、编译的时候一般是找到左边的引用类型方法
2、运行的时候一版是找到右边的对象类型方法
Father son1 = new Son();
son1(因为Father所以在编译时检测Father类是否有sleep函数).sleep()(如果有这个函数，那么在运行右边的也就是Son子类的对象函数);
多态的特性(静态函数):
1、优先处理本类的静态函数
* instanceof 是判断当前引用类型是什么类型
* 如：father instanceof Son
* 注意：在判断条件中，if条件不能写父类判断。
* 转型一般发生在继承的基础上：
1、必须有子类和父类
2、转型说到底还是子类的形态的转变。
*
* 注意：
* 1、转型发生时，如果这个对象是父类，
* 那么转型不可发生
*/
*
* 多态就是父类的引用指向子类。
* 其实真实的内存地址是子类
*
* 子类不能去表示一个父类
学习面向对象，最重要的是OOP思想。它不像C语言是面向过程，程序员就像执行者一步一步的做。就像案例大象与冰箱。C语言的执行过程是：1、人打开冰箱。 2、人把大象放进冰箱。3、人把冰箱关上。而面向对象则像是管理员。看这个案例有几个对象：在这个案例中，有人、大象、冰箱三个对象。管理员只要知道这几个对象之间要做什么，而不用管它怎么做。
笔记：
1.sleep 休息几秒，再执行下一个语句。
2.生成0-n的整数
Random random = new Random;
int k = random.nextInt(n);
4.构造函数当类被实例化后立即调用的函数
继承----------------------------------------------
* 继承:其实就是2个类之间的关系,由子类去继承父类,然后可以使用父类的所有的属性以及行为.
* 继承的优点:
* 1、子类继承父类，可以使用父类的属性
* 2、子类继承父类，可以使用父类的函数
* 3、子类继承父类，但是如果子类有相同名字以及返回值和参数的函数，那就优先调用子类的，这叫做覆盖或者重写
* 4: 一旦父类有构造函数,那么会调用去调用父类的
* 5: 如果子类也有构造函数,会优先去调用父类的构造函数
*/
* super(); 主动去调用父类的构造函数
* 一旦子类继承父类在实例化后,默认加载super();也就是默认加载父类的构造函数
*/
* 继承注意事项：
* 1、继承：子类继承父类，使用父类属性和函数。
* 2、继承在java中，不能多继承，但不代表不能多重继承。
* 3、一旦发生多重继承，先使用父类的，如果父类没有，使用父类的父类的。
* 4、超类和基类一般表示就是最开始的类，祖宗。
*
* 关联(普通朋友)、聚合(好朋友)、组合(基本一起死)
*
* 关联：一般是指 A类 和 B类只是一种普通的关系约束，例如：行为之间相互使用，但是并不影响各自的情况
* 聚合：一般是指 A类和B类，是一种整体与个体的关系，如：汽车和*的关系，但是少了*，它还叫汽车。
* 组合:一般是指 A类和B类，有一种与生俱来的关系，也就是刚开始2个对象就已经存在，一旦一个发生意外，那么另一个也即将销毁。
* final: 也是一种修饰符。可以作用于：函数、变量、类.
* final作用于类的时候，一般表示该类没有子类的情况下使用。
* 一旦作用于类，就不能就被继承。如：final class Person(){}
*
* final作用于函数的时候.那么这个函数就不能被子类重写。
* 如： final void run(){}
*
* final作用于变量的时候，一般说明这个变量只能赋值一次，一旦赋值就不能再改了。
* 如： final int a = 10; //在java中，一般这种表现形式为常量。
* final 的命名方式有所讲究：一般为 final int A = 10; final float P_I = 10f;
抽象-----------------------------------
* 抽象(abstract)：修饰符的一种
* 抽象也可以修饰类，方法
*
** 1、抽象类里可有抽象方法。
** 2、一旦定义了抽象方法，那么其子类必然需要实现父类的抽象方法。
**3、抽象类中的所有的抽象方法，在子类中都必须实现
** 4、抽象方法一定被定义，那么肯定这个类也是抽象类。 抽象类里可以没有抽象方法但是抽象方法必须在抽象类里。
**5、抽象方法本身不负责具体实现，由其子类负责具体实现。
** 6、抽象类本身不能被实例化。
** 7、abstract不能与final在一起，因为final是没有子类的，而abstract往往作用于父类，所以不能一起修饰
** 8、abstract不能与static与private在一起。
**9、抽象一般用于申明一些固定的方法，具体实现需要到子类
接口------------------------------------
*
* 接口：接口就是一组规范
* 接口：就是一旦遵守这组规范，你就必须要实现这些行为。
* 接口：一般与implements搭配使用，一个是接口，一个是实现。
* 接口：用的是interface关键字。
* interface 接口名{
* 属性 / 行为
* }
* 在interface内部每个属性都默认添加：
* public static final int PI = 1
* 如果没有，那是系统默认添加
* 在interface内部每个函数都会加public
* public void run()
*
* 因此，在接口中，所有的属性与函数都需要加public
* 因为，这些接口里的行为都需要实现。
*
* 在某种层次理解，接口就是加强版抽象。因为：
* 1、抽象类里不需要一定要有抽象函数。因此继承抽象，不需要一定实现非抽象方法。
* 2、但是接口一旦实现，那接口内部所有的函数，都需要都实现。
* 3、因此就相当于在抽象类内部，所有的属性都是final属性，所有函数都是抽象函数。
* 抽象与接口的区别：
* 1、抽象作用于类，一般都会有子类。
* 2、接口一般作用于函数。
* 3、抽象类只能单继承。接口也多实现,也能多继承(不推荐)。
* 4、抽象可以有方法体，但是接口没有。
* 5、实现接口必须要加入修饰符 public
*
* 为什么要有接口？
* 1、接口就是规范，定义实现这个事物标准
* 2、如果多个类去实现同一个接口里的方法(而不去写接口的话)，
* 是不知道这些行为属于同一类型的。
* 3、统一标准的目的就是为了让所有事物知道这个是“做什么”
但是具体不用知道“怎么做”
*
多态------------------------------------------------------
多态的前提：
*1、肯定会有继承。
*2、肯定会有重写
*3、肯定是父类去表示子类
多态的好处：
1、多种多态表示一个对象
2、当使用父类的形态表示子类的行为的时候，是可以减少代码冗余的。
3、多态有很好的可扩展性
* 多态的特性(非静态函数)：
* 1、编译的时候一般是找到左边的引用类型方法
2、运行的时候一版是找到右边的对象类型方法
Father son1 = new Son();
son1(因为Father所以在编译时检测Father类是否有sleep函数).sleep()(如果有这个函数，那么在运行右边的也就是Son子类的对象函数);
多态的特性(静态函数):
1、优先处理本类的静态函数
* instanceof 是判断当前引用类型是什么类型
* 如：father instanceof Son
* 注意：在判断条件中，if条件不能写父类判断。
* 转型一般发生在继承的基础上：
1、必须有子类和父类
2、转型说到底还是子类的形态的转变。
*
* 注意：
* 1、转型发生时，如果这个对象是父类，
* 那么转型不可发生
*/
*
* 多态就是父类的引用指向子类。
* 其实真实的内存地址是子类
*
* 子类不能去表示一个父类
上一篇： Terracotta下Grails的Ehcache缓存集群
下一篇： mysql无法启动解决