【JAVA300】41-45 笔记
2017-08-14 13:58
232 查看
41_面向对象_14_继承_super_
super是直接父类对象的引用。可以通过super来访问父类中被子类覆盖的方法或属性
普通方法:没有顺序限制,可以随便调用。
构造函数中:任何类的构造函数中,若是构造函数的第一行代码没有显式的调用super(```);
那么java默认都会调用super();作为父类的初始化函数。所以你这里的super();加不加都无所谓
代码:
package cn.bjsxt.oop.inherit;
public class Animal {
String eye;
public void run(){
System.out.println("跑泡!");
}
public void eat(){
System.out.println("吃吃!");
}
public void sleep(){
System.out.println("zzzzzzzzz!");
}
public Animal(){
super();
System.out.println("建一个动物");
}
}
class Mammal extends Animal{
public void run(){
System.out.println("跳跳");
}
public void taisheng(){
System.out.println("胎生!");
}
}
class Bird extends Animal {
public void run(){
System.out.println("飞飞!");
}
public void eggSheng(){
System.out.println("卵生!");
}
public Bird(){
super();
System.out.println("建一个鸟");
}
}
package cn.bjsxt.oop.inherit;
public class Test02 {
public static void main(String[] args){
ChildClass s1 = new ChildClass();
s1.f();
}
}
class FatherClass{
public int value;
public void f(){
value = 100;
System.out.println("FatherClass.value="+value);
}
}
class ChildClass extends FatherClass{
public int value;
public void f(){
super.f();
value = 200;
System.out.println("ChildClass.value="+value);
System.out.println(value);
System.out.println(super.value);
}
public ChildClass(){
super();
}
/*
class ChildClass extends FatherClass{
public int value;
public void f(){
super.f();
value = 200;
System.out.println("ChildClass.value="+value);
System.out.println(value);
System.out.println(super.value);
}
*/
}
42_面向对象_15_继承_组合
“is-a”关系使用继承!
——上面的通过在Audi类中添加一个Car属性虽然也复用了代码,但是不合逻辑不容易理解
“has-a”关系使用组合!
——计算机类,主板类。可以通过在计算机类中增加主板属性来复用主板类的代码!
package cn.bjsxt.oop.inherit;
/**
* 测试组合
* @author jiahao
*
*/
public class Animal2 {
String eye;
public void run(){
System.out.println("跑泡!");
}
public void eat(){
System.out.println("吃吃!");
}
public void sleep(){
System.out.println("zzzzzzzzz!");
}
public Animal2(){
super();
System.out.println("建一个动物");
}
public static void main(String[] args){
Bird2 b = new Bird2();
b.run();
b.animal2.eat();
}
}
class Mammal2 {
Animal2 animal2;
public void taisheng(){
System.out.println("胎生!");
}
}
class Bird2 {
Animal2 animal2 = new Animal2();
public void run(){
animal2.run();
System.out.println("飞飞!");
}
public void eggSheng(){
System.out.println("卵生!");
}
public Bird2(){
super();
System.out.println("建一个鸟");
}
}
43_16_final_修饰变量_方法_类
final
修饰变量:——常量
修饰方法:——该方法不可被子类重写。但是可以被重载!
修饰类:——修饰的类不能有子类,不能被继承。比如:Math,String.
package cn.bjsxt.oop.testFinal;
public /*final*/class Animal { //final加到类前面,这个类不能被继承!最末类
public /*final*/ void run(){ //final加到方法前面,意味着该方法不能被子类重写,最末方法
System.out.println("跑泡!");
}
}
class Bird extends Animal{
public void run(){
super.run();
System.out.println("建一个鸟");
}
}
package cn.bjsxt.oop.testFinal;
public class TestFinal {
public static void main(String[] args){
final int MAX_VALUE= 200;
//MAX_VALUE= 300;最终变量
double d = Math.PI;
}
}
44_面向对象_17_封装
encapsulation
隐藏对象内部的复杂性,只对外公开简单的接口。便于外界调用,从而提高系统的可扩展性,可维护性
我们程序设计要追求“高内聚, 低耦合“
高内聚就是类的内部数据操作细节自己完成,不允许外部干涉;
低耦合:仅暴露少量的方法给外部使用
private(私有):同一个类
default(默认):同一个类,同一个包
protected(保护):同一个类,同一个包,子类
public(公开):同一个类,同一个包,子类,所有类
封装要点
类的属性的处理:
1.一般使用private(除非本属性确定会让子类继承)
2.提供相应的get/set方法来访问相关属性。这些方法通常为public,从而提供对属性的读取操作(注意:boolean变量的get方法是用:is开头!)
一些只用于本类的辅助性方法可以用private
希望其他类调用的方法用public
set,get方法
45_面向对象_18_多态_基本概念_强制转型问题_instanceof运算符.wmv
多态polymorphism
多态性是面向对象的一个重要特性,主要是用来实现动态联编的,换句话说,就是程序的最终状态只能在执行过程中才被决定而非在编译期间就决定了。这对于大型系统来说提高系统的灵活性和扩展性
引用变量的两种类型:
编译时类型(模糊一点,一般是一个父类)由声明时的类型决定,
运行时类型(运行时,具体是哪个子类就是哪个子类)由实际对应的对象类型决定。
多态的存在要有三个必要条件:
要有继承,要有方法重写,父类引用指向子类对象 、、{方法的多态}
super是直接父类对象的引用。可以通过super来访问父类中被子类覆盖的方法或属性
普通方法:没有顺序限制,可以随便调用。
构造函数中:任何类的构造函数中,若是构造函数的第一行代码没有显式的调用super(```);
那么java默认都会调用super();作为父类的初始化函数。所以你这里的super();加不加都无所谓
代码:
package cn.bjsxt.oop.inherit;
public class Animal {
String eye;
public void run(){
System.out.println("跑泡!");
}
public void eat(){
System.out.println("吃吃!");
}
public void sleep(){
System.out.println("zzzzzzzzz!");
}
public Animal(){
super();
System.out.println("建一个动物");
}
}
class Mammal extends Animal{
public void run(){
System.out.println("跳跳");
}
public void taisheng(){
System.out.println("胎生!");
}
}
class Bird extends Animal {
public void run(){
System.out.println("飞飞!");
}
public void eggSheng(){
System.out.println("卵生!");
}
public Bird(){
super();
System.out.println("建一个鸟");
}
}
package cn.bjsxt.oop.inherit;
public class Test02 {
public static void main(String[] args){
ChildClass s1 = new ChildClass();
s1.f();
}
}
class FatherClass{
public int value;
public void f(){
value = 100;
System.out.println("FatherClass.value="+value);
}
}
class ChildClass extends FatherClass{
public int value;
public void f(){
super.f();
value = 200;
System.out.println("ChildClass.value="+value);
System.out.println(value);
System.out.println(super.value);
}
public ChildClass(){
super();
}
/*
class ChildClass extends FatherClass{
public int value;
public void f(){
super.f();
value = 200;
System.out.println("ChildClass.value="+value);
System.out.println(value);
System.out.println(super.value);
}
*/
}
42_面向对象_15_继承_组合
“is-a”关系使用继承!
——上面的通过在Audi类中添加一个Car属性虽然也复用了代码,但是不合逻辑不容易理解
“has-a”关系使用组合!
——计算机类,主板类。可以通过在计算机类中增加主板属性来复用主板类的代码!
package cn.bjsxt.oop.inherit;
/**
* 测试组合
* @author jiahao
*
*/
public class Animal2 {
String eye;
public void run(){
System.out.println("跑泡!");
}
public void eat(){
System.out.println("吃吃!");
}
public void sleep(){
System.out.println("zzzzzzzzz!");
}
public Animal2(){
super();
System.out.println("建一个动物");
}
public static void main(String[] args){
Bird2 b = new Bird2();
b.run();
b.animal2.eat();
}
}
class Mammal2 {
Animal2 animal2;
public void taisheng(){
System.out.println("胎生!");
}
}
class Bird2 {
Animal2 animal2 = new Animal2();
public void run(){
animal2.run();
System.out.println("飞飞!");
}
public void eggSheng(){
System.out.println("卵生!");
}
public Bird2(){
super();
System.out.println("建一个鸟");
}
}
43_16_final_修饰变量_方法_类
final
修饰变量:——常量
修饰方法:——该方法不可被子类重写。但是可以被重载!
修饰类:——修饰的类不能有子类,不能被继承。比如:Math,String.
package cn.bjsxt.oop.testFinal;
public /*final*/class Animal { //final加到类前面,这个类不能被继承!最末类
public /*final*/ void run(){ //final加到方法前面,意味着该方法不能被子类重写,最末方法
System.out.println("跑泡!");
}
}
class Bird extends Animal{
public void run(){
super.run();
System.out.println("建一个鸟");
}
}
package cn.bjsxt.oop.testFinal;
public class TestFinal {
public static void main(String[] args){
final int MAX_VALUE= 200;
//MAX_VALUE= 300;最终变量
double d = Math.PI;
}
}
44_面向对象_17_封装
encapsulation
隐藏对象内部的复杂性,只对外公开简单的接口。便于外界调用,从而提高系统的可扩展性,可维护性
我们程序设计要追求“高内聚, 低耦合“
高内聚就是类的内部数据操作细节自己完成,不允许外部干涉;
低耦合:仅暴露少量的方法给外部使用
private(私有):同一个类
default(默认):同一个类,同一个包
protected(保护):同一个类,同一个包,子类
public(公开):同一个类,同一个包,子类,所有类
封装要点
类的属性的处理:
1.一般使用private(除非本属性确定会让子类继承)
2.提供相应的get/set方法来访问相关属性。这些方法通常为public,从而提供对属性的读取操作(注意:boolean变量的get方法是用:is开头!)
一些只用于本类的辅助性方法可以用private
希望其他类调用的方法用public
set,get方法
45_面向对象_18_多态_基本概念_强制转型问题_instanceof运算符.wmv
多态polymorphism
多态性是面向对象的一个重要特性,主要是用来实现动态联编的,换句话说,就是程序的最终状态只能在执行过程中才被决定而非在编译期间就决定了。这对于大型系统来说提高系统的灵活性和扩展性
引用变量的两种类型:
编译时类型(模糊一点,一般是一个父类)由声明时的类型决定,
运行时类型(运行时,具体是哪个子类就是哪个子类)由实际对应的对象类型决定。
多态的存在要有三个必要条件:
要有继承,要有方法重写,父类引用指向子类对象 、、{方法的多态}
相关文章推荐
- Java学习笔记:JNI的使用(2016年1月13日14:21:45)
- 【JAVA300】21-25 笔记
- (41)21.4.1 并发 练习 17---Java编程思想之并发笔记
- Java基础知识强化之IO流笔记41:字符流缓冲流之复制文本文件案例02(使用 [ newLine() / readLine() ] )(重要)
- 【JAVA300】26-30 笔记
- Java学习笔记45(多线程二:安全问题以及解决原理)
- Java基础知识强化之IO流笔记45:IO流练习之 把集合中的数据存储到文本文件案例
- 【JAVA300】51-55 笔记
- 【Java学习笔记】41:学习用JFrame制作界面(两个界面空壳)
- (45)Java学习笔记——多线程 / 设置线程 / 线程调度 /线程控制
- Java学习笔记45:Java 线程与主线程之间的变量关系
- (45)21.4.3 并发 练习 19---Java编程思想之并发笔记
- 【JAVA300】56-60 笔记
- 【JAVA300】0-5 笔记
- 【JAVA300】31-35 笔记
- Java基础知识强化之集合框架笔记45:Set集合之TreeSet存储自定义对象并遍历练习1(自然排序)
- Androidx学习笔记(45)--- 获取文件的后缀名(java基本语法)
- 剑指offer面试题 java解答41-45
- 【Java学习笔记】45:优先级队列PriorityQueue和比较器Comparator
- Java基础知识强化之集合框架笔记41:Set集合之HashSet存储自定义对象并遍历练习