目录
理解封装的好处和javabean的规范
首先我们必须明白一点，封装是Java语言的风格或者说是所有面向对象类语言的风格。
如果没有这一特性，那么也就谈不上什么OOP了，所以我们平时在编写Java代码时，不管是否有意义或者显得有些多余，我们仍然要将其进行封装。
封装的作用：
1.提高代码的安全性。
2.提高代码的可复用性。
3.将代码模块化。
封装时需要注意些什么呢？
1.成员变量(属性)建议或者说是尽量使用private修饰；
2.成员方法一般使用public修饰；
3.通过使用getXxx(),setXxx()方法来获取和设置成员变量(属性);
示例代码如下：
package test02;
public class Test04 {
String name = "张三";
int age = 22;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
掌握四种访问权限
public，protected，default(缺省)，private四个访问权限依次降低，如果是默认权限则不需要显式的写出来。
理解继承的思想和好处
1.继承提高了代码的复用性。
2.继承使得类与类产生了关系和联系，这正是多态的前提。
3.java中只有单继承(与c++不同哦)，也就是说一个类只能继承一个类；如果你看到一个类如果没有显式的用extends继承一个类的话，那么这个类默认继承了Object;
4.子类拥有父类的所有属性和方法。
5.子类可以拥有自己的属性和方法。
6.子类可以覆写父类的方法，当父类中的方法不能满足子类的需要的时候就可以进行覆写，覆写的要求是：方法名、参数必须和父类一致，返回值类型必须【小于等于】父类方法的返回值类型(换句话说也就是必须是父类的子类型)，权限必须【大于等于】父类方法的权限
7.需要覆写的时候可以用@Override进行验证。
掌握重写的意义和规范，区分重写和重载
- 方法重载
特点：方法名相同，参数列表不同(参数类型，参数个数，参数顺序)；满足这两个条件即可构成重载；一般在同一个类中构成重载。
- 方法重写
特点：方法名相同，且参数列表相同；返回值类型子类的类型小于父类的类型；访问修饰符子类的类型大于父类的类型；一般在不同类中构成重写。
掌握super关键字的使用，以及super和this的区别
注：super()用法部分转载于：https://blog.csdn.net/My_name_is_ZwZ/article/details/80048056
个人感觉写的很好，所以直接引用他的；
super( )的用法
大白话解释一下super( ) : super( )其实就相当于一个指向基类的指针，（Java中没有指针，但是可以这样理解）。至于用法有一下四种形式：
1. super.XXX( 这里的XXX指的是父类的成员变量名即父类的属性，或者对象名)
2. super.XXX( ) ( 这里的XXX是父类中的其中一个方法名)
3. super( ) ( 这种形式指的是：调用父类没有参数的构造方法（也叫构造函数）注意： 这里super( ) 只能放在子类的 构造方法里面，并且只能放在构造方法的首句)
4. super( x,y,z...) （此形式指：调用父类有参数的构造方法，也必须放在子类的构造方法（成员方法不可以）里面， 并且只能放在构造方法的首句。其中x,y,z是指的与父类此有参构造方法中参数数据类型相对应的子类中的参数）。以上就是super( )的四种应用形式，具体的应用看以下代码：
1. super的第一种应用形式即调用父类的成员变量：
package com.test;
public class Father {
protected String head = "我的头又圆又大";
Father(){
System.out.println(head);
}
Father(int a){
System.out.println(a);
}
}
package com.test;
public class Son extends Father{
private static int a = 1;
public Son(){
//super.head = " ";
System.out.println(super.head);//调用父类Father中的属性head并且输出
System.out.println(head);//调用父类Father中的属性head并且输出
//super();
//super(a);
}
public void test(){
//super(int a);
//super.head = "abc";
//System.out.println(head);
}
public static void main(String[] args) {
Son s = new Son();
//s.test();
}
}
以上代码的输出结果是：
可见：两条输出语句在控制台的输出结果相同，所以它们的作用是一样的。head就和super.head等价。但是平时为了方便不会把super.加上去。（这里的super.XXX和属性的访问修饰符不会发生冲突，也就是说父类的私有变量只能通过父类定义好的调用私有属性的方法去调用和改变，super关键字也无权调用）
2. super的第二种应用形式即利用super关键字调用父类的无参构造方法：
package com.test;
public class Father {
public String head = "我的头又圆又大";
Father(){
System.out.println(head);
}
Father(int a){
System.out.println(a);
}
}
package com.test;
public class Son extends Father{
private static int a = 1;
public Son(){
//super.head = " ";
//System.out.println(super.head);//调用父类Father中的属性head并且输出
//System.out.println(head);//调用父类Father中的属性head并且输出
//super();
//super(a);
}
public void test(){
//super(int a);
//super.head = "abc";
//System.out.println(head);
}
public static void main(String[] args) {
Son s = new Son();
//s.test();
}
}
其运行结果：
为什么在Son这个类中并没有一条输出语句，但是还是输出了一句话？就是因为用new关键字去创建对象的时候，会去调用此类的构造方法，而在此构造方法中的第一句，就默认为是：super( )，也就是去调用了父类的无参构造方法 这一句代码是自动加上去的，哪怕自己不在第一行写上：super( )，就像写一个类，如果不写这个类的构造方法的话，会自动加上一个public void修饰的，并且方法体为空的方法一样，当然自己加上也是可以的，但是加的时候必须要在子类构造方法的第一句。
3. super的第三种应用形式即利用super关键字调用父类的有参构造方法：
package com.test;
public class Father {
public String head = "我的头又圆又大";
Father() {
System.out.println(head);
}
Father(int a) {
if (a == 1) {
System.out.println("你们给我的参数是1");
}
if (a == 2) {
System.out.println("你们给我的参数是2");
}
}
Father(String str) {
System.out.println("儿子，儿子~我是你爸爸");
}
}
package com.test;
public class Son extends Father {
private static int a = 1;
private static String str = "ZwZ";
public Son() {
// System.out.println(super.head);//调用父类Father中的属性head并且输出
// System.out.println(head);//调用父类Father中的属性head并且输出
// super();
super(a);//调用父类的，有参数的，并且参数为int类型的构造方法
//super(str);
}
public Son(String str){
super(str);//调用父类的，有参数的，并且参数为String类型的构造方法
}
public void test() {
// super(int a);
// super.head = "abc";
// System.out.println(head);
}
public static void main(String[] args) {
Son s = new Son();
Son s2 = new Son(str);
// s.test();
}
}
其运行结果为：
可见super( )和super（str）分别调用了父类的Father( )和Father( String str )两个构造方法
4. super的第四种应用形式即利用super关键字调用父类的成员方法：
package com.test;
public class Father {
public String head = "我的头又圆又大";
Father() {
System.out.println(head);
}
Father(int a) {
if (a == 1) {
System.out.println("你们给我的参数是1");
}
if (a == 2) {
System.out.println("你们给我的参数是2");
}
}
Father(String str) {
System.out.println("儿子，儿子~我是你爸爸");
}
public static String demo(String str) {
System.out.println(str);
return str;
}
}
package com.test;
public class Son extends Father {
private static int a = 1;
private static String str = "我叫张文哲";
/*
* public Son() { System.out.println(super.head);//调用父类Father中的属性head并且输出
* System.out.println(head);//调用父类Father中的属性head并且输出 super();
* super(a);//调用父类的，有参数的，并且参数为int类型的构造方法 }
*/
public Son(String str) {
// super(str);//调用父类的，有参数的，并且参数为String类型的构造方法
String strCopy = super.demo(str);// 调用父类的成员方法demo，并且用strCopy接收此方法返回的字符串
System.out.println(strCopy);// 输出strCopy接收的内容以验证
}
public static void main(String[] args) {
// Son s = new Son();
Son s2 = new Son(str);
}
}以上代码的输出结果：
又以上结果可知，理论与实践相符！！！（其中“我的头又大又圆”这句话之所以输出，是因为在Son（String str）此构造方法里面自动加上了super（）而在Father( )里面有向控制台输出的语句。）
#注意#：
1. 在子类的构造方法里面，super( )和super( x,y,z...)这能用其中一个，（其他两种没有这种要求），否则编译器会报错
2.看到最后的同志们，可能都是比较爱学习或者对编程感兴趣的同道中人。那么送君一句话：拒绝眼高手低，拒绝唱高调，拒绝装逼，拒绝浮躁，拒绝自以为是。人外有人，天外有天
3.在构造子类对象的同时，会构造父类对象。（因为在调用自类构造方法的时候，第一句代码默认的便是super（），它调用了父类的构造方法）
补充：如果父类写了带参的构造方法，那么最好把无参构造也写上，因为当子类继承父类的时候，子类的构造器会自动调用父类的无参构造器，如果没有会报错；除非你子类构造器中显示的写出带参构造器super(x,y,z)，这样也行。
this关键字的用法
- this始终指向本类对象
- this可以调用本对象的所有属性以及成员方法
- this可以调用本类的构造方法
- this还可以返回当前对象的引用
注：当在一个类的一个方法里出现了同名变量，此时可以使用this，eg：this.name = name;
了解继承和组合所表述的关系，合理的使用继承和组合
继承和组合都是面向对象中代码复用的方式。父类的内部细节子类基本都可见，是is-a关系；
例如：父类-动物类
子类1：猫类
子类2：狗类
猫和狗都是动物，is- a关系；
而对于组合是对象之间的细节互相不可见，是has-a关系。
例如：父类-汽车
子类1：轮胎
子类2：车窗
车窗和轮胎不能说是汽车吧(轮胎跟车窗都是汽车的一部分)。所以他们之间就不能是继承关系，而是组合关系。
268
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
