面向对象知识点梳理(2)

                                  黑马程序员    

面向对象知识点梳理(2)

------- android培训、java培训、期待与您交流！----------

(一)构造方法

1:构造方法的作用是什么?构造方法的特点是什么?
构造方法的注意事项是什么?构造方法中可不可以写return语句呢?
答：作用是给对象的数据进行初始化。   特点：方法名与类名相同。没有返回值类型，连void也没有。没有具体的返回值。   注意事项：如果你不提供构造方法系统会默认给出构造方法，如果你提供了构造方法系统将不再提供构造方法有可以重载。


2:给成员变量赋值有几种方式?
答：1.无参构造方法+setXxx()。2.带参数构造方法。


3:标准的代码编写及测试：
A:学生类的案例
//需求：定义小屁孩  属性：姓名，身高，长相   行为：洗衣，做饭，唱歌。跳舞，虽然这些都不会


class GodnessTest{
public static void main (String  [] args){
//创建对象
Godness g = new Godness();
//获取数据
g.setName("小王");
g.setAge(28);
g.setFace("漂亮");
System.out.println("我对象的名字叫"+g.getName()+"她的年         龄是"+g.getAge()+"她长得"+g.getFace()+"也很温柔哦！！虽         然我也不相信^_^");
g.wash();
g.cook();
g.sing();//容易出错的地方不能连着打印。
System.out.println("每当周末的时候她就");         g.wash();
System.out.println("然后到了中午的时候就");        g.cook(); System.out.println("在我工作很累的时候           就");
g.sing(); System.out.println("你说我对象是不是很          完美！！！");
}
}
class Godness
{
//私有化属性
private String name;
private int age ;
private String face ;
//定义set/get属性
public void setName(String name){
this.name = name;
}

继承

1:代码块是什么?代码块的分类和各自特点?


答：在Java中，使用{}括起来的代码被称为代码块，根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块


2:静态代码块,构造代码块,构造方法的执行流程?


答：局部代码块：
在方法中出现；限定变量生命周期，及早释放，提高内存利用率。
  构造代码块：
在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行
静态代码块 在类中方法外出现，加了static修饰
在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且值执行一次。-------------------------------------------------------
3:继承概述


答：多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。通过extends关键字可以实现类与类的继承。4:继承的好处


答：提高了代码的复用性
多个类相同的成员可以放到同一个类中
提高了代码的维护性
如果功能的代码需要修改，修改一处即可
让类与类之间产生了关系，是多态的前提
5:Java中继承的特点
答：1.只支持单继承，不支持多继承。2.支持多层继承


6:Java中继承的注意事项?以及我们什么时候使用继承?


答：1.子类只能继承父类所有非私有的成员(成员方法和成员变量)
其实这也体现了继承的另一个弊端：打破了封装性
  2.子类不能继承父类的构造方法，但是可以通过super(后面讲)关键字去访问父类构造方法。3.
不要为了部分功能而去继承   答：当类中的体现是is a 的关系时使用继承。
7:继承中的成员访问特点
A:成员变量
在子类方法中访问一个变量
答：首先在子类局部范围找
然后在子类成员范围找
最后在父类成员范围找(肯定不能访问到父类局部范围)
如果还是没有就报错。(不考虑父亲的父亲…)
B:成员方法
在测试类中通过子类对象去访问一个方法
答：通过子类对象去访问一个方法
首先在子类中找
然后在父类中找
如果还是没有就报错。(不考虑父亲的父亲…)8:继承中构造方法的执行流程?假如父类没有无参构造方法，子类应该怎么办?
答：子类通过super去显示调用父类其他的带参的构造方法
子类通过this去调用本类的其他构造方法
本类其他构造也必须首先访问了父类构造
一定要注意：
super(…)或者this(….)必须出现在第一条语句上
否则，就会有父类数据的多次初始化
9:面试题：
方法重写和方法重载的区别?方法重载能改变返回值类型吗?
Overload  重载是指：在同一个类中方法名相同参数列表不同，与返回值无关。可以改变返回值类型。
Override  重写是指：子类中出现了和父类中一模一样的方法声明，也被称为方法覆盖，方法复写。
this关键字和super关键字分别代表什么?以及他们各自的使用场景和作用。
 答：this关键字是指在本类中
10:继承案例练习


动物 {
姓名,年龄,腿的个数
构造方法
get()/set()
睡觉();
吃();


} 
猫{
姓名,年龄,腿的个数
构造方法
get()/set()
睡觉();
吃(); //吃鱼

}
狗{
姓名,年龄,腿的个数
构造方法
get()/set()
睡觉();
吃(); //吃骨头
}




Person 类, 老师和学生类 




11:final关键字可以干什么?有什么特点?
答：final关键字是最终的意思.
可以修饰类，成员变量，成员方法。


修饰类，类不能被继承
修饰变量，变量就变成了常量，只能被赋值一次
修饰方法，方法不能被重写
12:final关键字的面试题?
A:修饰局部变量,能够被更改
答：1.在方法内部，该变量不可以被大改变。
    2.在方法声明上，基本类型：是之不能被改变。
    3.引用剋行，是地址知不能被改变。


B:在什么时候可以初始化?
答对象构造完毕前即可！

(二)案例分析

1.学生和老师案例

/*
完整的案例   学生 老师   
继承前: 
分析:
class 学生 {
成员变量 
姓名 
年龄
学号

构造方法 
无参
有参




成员方法 
get/ set 
特有 
study(){}
sleep(){}
doNotHomework

}
class 老师 {
成员变量
姓名
年龄
工号 

构造方法

有参 


无参 

特有方法 
get /set 

上课

吃药

sleep(){ }
}
实现 :

继承后:
父类  class person{

成员变量
姓名 
年龄
构造
无参 
有参
成员变量
get /set

特有  
sleep
} 
*/

class {
public static void main(String[] args){
System.out.println();
}
}

class Student {
//成员变量 
private String name ;//姓名 
private int age;//年龄
private  String sNum;//学号

// 构造方法 
// 无参
Student(){}
// 有参
Student(String name,int age,String sNum){
this.name = name;
this.age = age;
this.sNum = sNum;
}

// 成员方法 
// get/ set 

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 String getSNum(){
return  sNum;
}
public  void setSNum(String sNum){
this.sNum = sNum;
}

// 特有 

public  void study(String course){
System.out.println("学 " + course );
}
public  void sleep(){
System.out.println("睡到天黑!");
}

public void doNotHomework (){
System.out.println("其实我写了,就是没有交...");

}
}

class Teacher {
//成员变量 
private String name ;//姓名 
private int age;//年龄
private  String wNum;//学号

// 构造方法 
// 无参
Teacher(){}
// 有参
Teacher(String name,int age,String wNum){
this.name = name;
this.age = age;
this.wNum = wNum;
}

// 成员方法 
// get/ set 


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 String getWNum(){
return  wNum;
}
public  void setWNum(String wNum){
this.wNum = wNum;
}

// 特有 
public  void teach(String course){
System.out.println("教 " + course );
}
public  void sleep(){
System.out.println("睡到五点就被吵醒了 !!!");
}


public void chiYao (){
System.out.println("健康多好啊...");

}
}

3.finaly 知识点小例

/*
final ,最终的意思, 被final修饰的方法,不能被重写.
类,变量,方法 都可以修饰  
类 :不能被继承 
变量 :自定义常量 ,通常情况下,我们用来定义url,port 
www.baidu.com/wenku/001.html
www.baidu.com/wenku/002.html
www.baidu.com/wenku/003.html


final String url = "www.baidu.com/wenku/";
url就是自定义常量.
final修饰的变量,只有在定义的时候,赋值一次,否则你就赋不上值了.
方法 : 不能被重写
*/
class FinalDemo{
public static void main(String[] args){
System.out.println();
Fu f = new Fu();
f.show();
}
}
//final class Fu { //错误: 无法从最终Fu进行继承
class Fu {
final int num =10;
public void show(){
//num = 20;
final int x ;
x =30;
x =40;
System.out.println(num);
System.out.println(x);
}
}

class Zi extends Fu{

}

4.成员变量

/*
看程序写结果:
构造函数 :
子类的构造函数,会默认调用父类无参构造,super();
但是 ,当父类没有无参构造的时候,子类必须显式的调用父类的有参构造.
面试用的
注意: 正常你写代码,是不会有这个问题的,因为我让你写的格式的标准的.  

*/
class Fu extends Object {
public int num;
// public Fu( ){
// //super();
// //
// System.out.println("fu");
// }

public Fu(int num){
this.num = num; 
System.out.println("Fu 有参构造");
}
}
class Zi extends Fu{
public int num = 20;
public Zi(){
//super();   //调用父类的无参构造方法  ,  创建子类对象前,会将父类进行初始化   ,默认也会调用

//super(0);
System.out.println("zi");
}
public void show(){
int num = 30;
System.out.println(num);     //局部变量, 遵循 就近原则   
System.out.println(this.num);  //当前对象的引用   this = 0x01
System.out.println(super.num); //理解为父类的引用  super 0x02 
}
}
class Test {
public static void main(String[] args) {
Zi z = new Zi();
z.show();
}
}