大数据之路week01--day02我实在时被继承super这些东西搞的头疼,今天来好好整理以下。
这一周的第一天的内容是面向对象的封装,以及对方法的调用。实在时没法单独拿出来单说,就结合这一节一起说了。
我实在是被继承中的super用法给弄的有点晕,程序总是不能按照我想的那样,不是说结果,而是实现过程,很明显复杂,后来进行推敲后,原来是我的理解出了差错。
先把前对象的的内容补补
在开始面向对象之前,我们先来了解一下,Java的内存分配:(在之前我也说过,只是简单的提到)
Java把内存划分为4个部分 1. 代码区 1、栈区 3、堆区 4、静态区域
1、栈区(stacksegment)—由编译器自动分配释放,存放函数的参数值,局部变量的值等,具体方法执行结束之后,系统自动释放JVM内存资源
2、堆区(heapsegment)—一般由程序员分配释放,存放由new创建的对象和数组,jvm不定时查看这个对象,如果没有引用指向这个对象就回收
3、静态区(datasegment)—存放全局变量,静态变量和字符串常量,不释放
4、代码区(codesegment)—存放程序中方法的二进制代码,而且是多个对象共享一个代码空间区域
一、面向对象的三大特性:
封装、继承、多态。
1、封装
在面向对象程式设计方法中,封装(英语:Encapsulation)是指一种将抽象性函式接口的实现细节部份包装、隐藏起来的方法。
封装可以被认为是一个保护屏障,防止该类的代码和数据被外部类定义的代码随机访问。
要访问该类的代码和数据,必须通过严格的接口控制。
封装最主要的功能在于我们能修改自己的实现代码,而不用修改那些调用我们代码的程序片段。
适当的封装可以让程式码更容易理解与维护,也加强了程式码的安全性。
1.1 封装的优点
1. 良好的封装能够减少耦合。
2. 类内部的结构可以自由修改。
3. 可以对成员变量进行更精确的控制。
4. 隐藏信息,实现细节。
1.2 实现Java封装的步骤
1. 修改属性的可见性来限制对属性的访问(一般限制为private),例如:
这段代码中,将 name 和 age 属性设置为私有的,只能本类才能访问,其他类都访问不了,如此就对信息进行了隐藏。
2. 对每个值属性提供对外的公共方法访问,也就是创建一对赋取值方法,用于对私有属性的访问,例如:
public class Person{
private String name;
private int age;
public int getAge(){
return age;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age = age;
}
public void setName(String name){
this.name = name;
}
}
采用 this 关键字是为了解决实例变量(private String name)和局部变量(setName(String name)中的name变量)之间发生的同名的冲突。
1.3 this
this指针:(实际上,每个非static方法中都隐含这一个this指针指向当前正在调用该方法的对象。)
1.4 static
static(静态的):
1、如果在一个属性的前面加上static ,那么这个属性就不是某一个对象的了,而是N个对象共用的了。在静态区存放,不释放。
static属性变量是属于类本身的,没有对象我们仍然可以通过类名的方式进行访问该类内部的static属性。(static方法也可以)
注意:类可以直接调用,实例化出来的对象当然也可以进行调用。
理解:模型都可以,模型造的对象当然可以。
2、加上static的确是属于类本身的,但是要去访问它必须控制符是非私有的,如果控制符是私有的,则不能直接通过类名进行访问!!
理解:private static void a(){} private static int i;都是不可以直接通过类名进行访问,因为前面的控制符是private
3、非静态的方法可以访问静态成员,反之不可以。非私有的静态成员才能通过类名直接调用。
理解:静态的方法和静态的变量属于类本身,不是静态的方法必须通过对象进行调用,在实例化对象的同时也包含了静态的方法,当然可以。反之不可以。
下面,我们用实例来理解static的作用:
实例1:实现一个类只允许有一个对象
package com.wyh.Iterator; /**
* @author WYH
* @version 2019年11月10日 上午10:18:07
* 该程序证明:
* 实现一个类只允许实例化一个对象
*/ class A2{
public int i = 2; private static A2 aa = new A2(); private A2() { } public static A2 getA2() {
return aa;
}
} public class static03 {
public static void main(String[] args) {
A2 aa1 = A2.getA2();
A2 aa2 = A2.getA2();
aa1.i = 90;
System.out.println("aa2:"+aa2.i);//说明aa1和aa2是同一个对象 if(aa1 == aa2) {
System.out.println("说明aa1和aa2是同一个对象");
}else {
System.out.println("说明aa1和aa2不是同一个对象");
}
} }
实例2:一个类无论实例化多少对象,其中一个变量只有一个。
package com.wyh.Iterator; /**
* @author WYH
* @version 2019年11月10日 上午9:32:57
*/
public class static01 {
private static int i; public static01() {
i = i+1;
} // static void add() {
// i = i+1;
// }
// public static void main(String[] args) {
static01 s1 = new static01();
// s1.add();
static01 s2 = new static01();
// s2.add();
static01 s3 = new static01();
// s3.add();
static01 s4 = new static01();
// s4.add();
static01 s5 = new static01();
// s5.add();
System.out.println("总共实例化了:"+i+"个对象");
} }
2、继承
什么是继承?在我们的后面实际操作过程中,很多时候,许多的对象拥有一些重复的操作,而且,这些对象都是同一种现实属性的派生。例如,我们的男人和女人都是人类,那么人类就是男人,女人的父类,男人和女人继承了人类这个父类,称之为子类。
1、继承,我们用extends来表示:比如刚刚说的男人继承了人类这个类 public class man extends human{}
2、提到了继承父类,那继承过来的成员变量和一些方法,我们怎么去使用呢?
2.1 super
终于讲到令人头疼的super了。
重写:当子类需要父类的功能,而子类有新的内容,可以重写父类中的方法。在实际开发过程中,随着代码量的逐渐增加,维护成了一个很大的问题,如果需要对某个方法进行修改,其本身代码以及其子类代码都会受到影响,而重写则很好的解决了这个问题。方法重写又称为方法覆盖、方法复写。
方法重写特点
在子类和父类中,出现了方法声明相同的情况
子类的方法声明要和父类相同
子类要重写的方法,方法的权限修饰符不能比父类更低(public 、protected 、default 、private 权限依次增加)
父类私有的方法,子类不能进行方法重写
方法重写和方法重载的区别:
方法重写:子类和父类中方法相同,两个类之间的关系,函数的返回值类型、函数名、参数列表都一样
方法重载:指在同一个类中,多个方法名相同,他们的参数列表不同(个数不同,数据类型不同)
重写方法时要注意的地方:
1.方法重写时, 方法名与形参列表必须一致。
2.方法重写时,子类的权限修饰符必须要大于或者等于父类的权限修饰符。
3.方法重写时,子类的返回值类型必须要小于或者 等于父类的返回值类型。
4.方法重写时, 子类抛出的异常类型要小于或者等于父类抛出的异常类型。 Exception(最坏) RuntimeException(小坏)
先来看一个例子:
A类:(父类)
package day02; /**
* @author WYH
* @version 2019年11月12日 下午2:52:37
*/
public class A { protected String name;
protected String health;
protected String love; public String getName() {
return name;
}
public String setName(String name) {
return this.name = name;
}
public String getHealth() {
return health;
}
public void setHealth(String health) {
this.health = health;
}
public String getLove() {
return love;
}
public void setLove(String love) {
this.love = love;
}
public A() {
super();
// TODO Auto-generated constructor stub
}
public void eat()
{
System.out.println("吃饭!");
}
public void work()
{
System.out.println("工作!");
}
public void sleep()
{
System.out.println("睡觉!");
} }
B类:(子类,继承了A父类)
package day02; /**
* @author WYH
* @version 2019年11月12日 下午2:53:02
*/
public class B extends A{
private int i; public int getI() {
return i;
} public void setI(int i) {
this.i = i;
} public B(){
super();
} public void work()
{
super.work(); //使用super关键字调用父类方法
System.out.println("学习!");
System.out.println("娱乐!"); }
}
D类:(子类,继承了A父类)
package day02; /**
* @author WYH
* @version 2019年11月12日 下午2:53:02
*/
public class D extends A{
private int i; public int getI() {
return i;
} public void setI(int i) {
this.i = i;
} public D(){
super();
} public void work()
{
super.work(); //使用super关键字调用父类方法
System.out.println("学习!");
System.out.println("娱乐!"); }
}
C类:(测试类,主类)
package day02; /**
* @author WYH
* @version 2019年11月12日 下午2:53:34
*/
public class C {
public static void main(String[] args) {
/*A aa = new A();
aa.work();*/ A bb = new B();
A dd = new D();
bb.name = bb.setName("456");
dd.name = dd.setName("123");
System.out.println(bb.name);
System.out.println(dd.name);
System.out.println(bb.getName());
bb.work();
} }
解说:
我们可以看到,我现在父类,A类种定义了name;health;love;三个成员变量,为了可以实现继承,我们不将它定义成私有变量,同时父类里面拥有三个方法,吃饭,睡觉,工作。
B类和D类继承了A类,同时我们将work方法进行了重写,添加了自己特有的方法。
然后,我们来看看结果:
后来,我们发现,通过super,可以调用父类的方法,以及可以通过super调用父类的成员变量。这个例子很好的概括,this指针,super的用法,重写的用法。
多态我们后续进行补充。。。
最新文章
- Linux-read命令
- Python 3.x下消除print()自动换行
- JBOSS通过Apache负载均衡方法二:使用mod_cluster
- caffe windows学习:第一个测试程序
- C# 检测网络链接
- (转载)Javascript 进阶 作用域 作用域链
- Connect mysql on Linux from Windows
- [HNOI 2013] 旅行 (数学)
- iOS常用的封装方法
- springmvc框架下ajax请求传参数中文乱码解决
- flume日志采集框架使用
- Java获得系统的外网IP
- Dynamics CRM 构建IN查询
- .net 委托多线程 实时更新界面
- JavaScript字符串转换为数字
- AngularJS中$interval的用法
- Pandas选择数据
- IT高管和易筋经的故事
- tf.contrib.rnn.static_rnn与tf.nn.dynamic_rnn区别
- numpy 数组创建例程