黑马程序员_java基础之面向对象封装及继承

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

1.面向对象(面向对象开发,设计以及特征)

1.1面向对象开发

      就是不断的创建对象，使用对象，指挥对象做事情。

1.2面向对象设计

      其实就是在管理和维护对象之间的关系。

面向对象特征:   封装(encapsulation)

                      继承(inheritance)

                      多态(polymorphism)

面向对象(学生类的使用)

 A:文件名问题

      在一个java文件中写两个类：一个基本的类，一个测试类。

      建议：文件名称和测试类名称一致。

 B:使用对象:     创建对象并使用

                      格式：类名 对象名 = new 类名();

D:使用成员变量:      对象名.变量名

E:使用成员方法:      对象名.方法名(...)

1.3一个标准的电脑类及其测试类

class ComputerTest  {
public static void main(String[] args)  {
Computer c = new Computer();
c.setBrand ("DELL");
c.setPrice ( 2000);
c.study();
c.playGame();
System.out.println("我的电脑收:"+ c.getBrand()+",价格是:"+c.getPrice());
}
}

class Computer {

private String brand;
private int price;

public void setBrand(String brand){
this.brand = brand;
}

public String getBrand(){
return brand;
}

public void setPrice(int price) {
this.price = price;
}

public int getPrice(){
return price;
}

public void study(){
System.out.println("用电脑学习");

}

public void playGame(){
System.out.println("用电脑打游戏");

}
}

2.成员变量和局部变量的区别

 A:在类中的位置不同:    成员变量：在类中方法外

                                  局部变量：在方法定义中或者方法声明上

B:在内存中的位置不同:

成员变量：在堆内存(成员变量属于对象,对象进堆内存)

局部变量：在栈内存(局部变量属于方法,方法进栈内存)

C:生命周期不同

      成员变量：随着对象的创建而存在，随着对象的消失而消失

      局部变量：随着方法的调用而存在，随着方法的调用完毕而消失

D:初始化值不同

      成员变量：有默认初始化值

      局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。

     

E:注意事项：

局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。

2.1方法的形式参数或返回值是类名的时候

A:方法的参数是类名public void print(Students){}//print(new Student());

      如果你看到了一个方法的形式参数是一个类类型(引用类型)，这里其实需要的是该类的对象。

 B:方法的返回值是类名public Student print(){return s}

      如果你看到了一个方法的返回值是类名,这里其实返回的是该类对象

2.2匿名对象:

匿名对象应用场景

      a:调用方法，仅仅只调用一次的时候:节省代码 ,调用多次的时候，不适合。匿名对象调用完毕就是垃圾。可以被垃圾回收器回收。

      b:匿名对象可以作为实际参数传递

3.面向对象(封装的概述)

封装概述:隐藏对象的属性和实现细节，仅对外提供公共访问方式

A:封装好处:       隐藏实现细节，提供公共的访问方式

                      提高了代码的复用性

                      提高安全性。

B:封装原则:       将不需要对外提供的内容都隐藏起来。

   把属性隐藏，提供公共方法对其访问。

4.关键字

      Private:       是一个权限修饰符

                      可以修饰成员变量和成员方法

                      被其修饰的成员只能在本类中被访问

this :          代表当前对象的引用

this的应用:       区分成员变量和局部变量重名

static:         a:随着类的加载而加载

                      b:优先于对象存在

                      c:被类的所有对象共享

           如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的。

                      d:可以通过类名调用,其实它本身也可以通过对象名调用。

           静态修饰的内容一般我们称其为：与类相关的，类成员

注意事项

           a:在静态方法中是没有this关键字的

                  静态是随着类的加载而加载，this是随着对象的创建而存在。

                  静态比对象先存在。

           b:静态方法只能访问静态的成员变量和静态的成员方法

                 静态方法：  成员变量：只能访问静态变量

                                  成员方法：只能访问静态成员方法

           非静态方法：

                 成员变量：可以是静态的，也可以是非静态的

                 成员方法：可是是静态的成员方法，也可以是非静态的成员方法。

           简单记：     静态只能访问静态。

5.面向对象(构造方法Constructor概述和格式)

A:构造方法概述和作用

      给对象的数据(属性)进行初始化

B:构造方法格式特点

      a:方法名与类名相同(大小也要与类名一致)

      b:没有返回值类型，连void都没有

      c:没有具体的返回值return;

C:构造方法注意事项

      a:如果我们没有给出构造方法，系统将自动提供一个无参构造方法。

      b:如果我们给出了构造方法，系统将不再提供默认的无参构造方法。

      注意：这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法

D:给成员变量赋值的两种方式:     a:setXxx()方法

                                              
 b:构造方法

5.1成员方法的分类及使用

A:成员方法分类

    
4000
   a:根据返回值:        有明确返回值方法

                                  返回void类型的方法

       b:根据形式参数:     无参方法

                                  带参方法

5.2Student s = new Student();做了哪些事情

      1,Student.class加载进内存

      2,声明一个Student类型引用s

      3,在堆内存创建对象,给对象中属性默认初始化值

     4,构造方法进栈,对对象中的属性赋值,构造方法弹栈

      5,将对象的地址值赋值给s

5.3一个标准的学生类及其测试类

class StudentTesta  {
public static void main(String[] args)  {
Student s = new Student();
s.setName("小名");
s.setAge(12);
s.study();
s.eat();
s.sleep();
System.out.println(s.getName()+"的年龄是:"+s.getAge());
}
}
class Student {

private String name;
private int age;

public void setName(String nn){
name = nn;
}

public String getName(){
return  name;
}

public void setAge(int m){
age = m;
}

public int getAge(){
return  age;
}

public void study(){
System.out.println("我爱学习");
}

public void eat(){
System.out.println("吃饭");
}

public void sleep(){
System.out.println("睡觉");
}
}

6.静态变量和成员变量的区别

6.1静态变量也叫类变量  成员变量也叫对象变量

A:所属不同: 静态变量属于类，所以也称为为类变量

成员变量属于对象，所以也称为实例变量(对象变量)

B:内存中位置不同

            静态变量存储于方法区的静态区

                 成员变量存储于堆内存

C:内存出现时间不同

                 静态变量随着类的加载而加载，随着类的消失而消失

成员变量随着对象的创建而存在，随着对象的消失而消失

D:调用不同

           	静态变量可以通过类名调用，也可以通过对象调用

                 成员变量只能通过对 象名调用

6.2主方法的解释:publicstatic void main(String[] args) {}

      public被jvm调用，访问权限足够大。

      static被jvm调用，不用创建对象，直接类名访问

      void被jvm调用，不需要给jvm返回值

      main一个通用的名称，虽然不是关键字，但是被jvm识别

      String[]args 以前用于接收键盘录入的

7.代码块的概述和分类

A:代码块概述:在Java中，使用{}括起来的代码被称为代码块。

B:代码块分类:根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块(多线程讲解)。

C:常见代码块的应用

      a:局部代码块 :在方法中出现；限定变量生命周期，及早释放，提高内存利用率

      b:构造代码块 (初始化块):在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行

      c:静态代码块:在类中方法外出现，加了static修饰,在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且只执行一次。

8.继承的好处和弊端

A:继承的好处:    a:提高了代码的复用性

                      b:提高了代码的维护性

                      c:让类与类之间产生了关系，是多态的前提

B:继承的弊端

                      类的耦合性增强了。

                开发的原则：高内聚，低耦合。

8.1Java中类的继承特点

      a:Java只支持单继承，不支持多继承。(一个儿子只能有一个爹)

      b:Java支持多层继承(继承体系)

      c:如果想用这个体系的所有功能用最底层的类创建对象

      d:如果想看这个体系的共性功能,看最顶层的类

8.2继承的注意事项和什么时候使用继承

      a:子类只能继承父类所有非私有的成员(成员方法和成员变量)

      b:子类不能继承父类的构造方法，但是可以通过super(马上讲)关键字去访问父类构造方法。

      c:不要为了部分功能而去继承

8.3this和super的区别和应用

      Super:子类局部范围访问父类成员变量

      a:调用成员变量

           this.成员变量 调用本类的成员变量,也可以调用父类的成员变量

           super.成员变量 调用父类的成员变量

      b:调用构造方法

            this(...)     调用本类的构造方法

            super(...)   调用父类的构造方法

       c:调用成员方法

           this.成员方法 调用本类的成员方法,也可以调用父类的方法

           super.成员方法 调用父类的成员方法

8.4继承中构造方法的关系

      子类中所有的构造方法默认都会访问父类中空参数的构造方法

      因为子类会继承父类中的数据，可能还会使用父类的数据。

      所以，子类初始化之前，一定要先完成父类数据的初始化。

      每一个构造方法的第一条语句默认都是：super()在这里简单的提一句，Object类。否则有人就会针对父类的构造方法有疑问。Object在没有父类了。

继承中构造方法的注意事项

      父类没有无参构造方法,子类怎么办:   super解决

                                                       this解决

注意:    super(…)或者this(….)必须出现在第一条语句上

8.5方法重写应用

      当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。这样，即沿袭了父类的功能，又定义了子类特有的内容。

8.6方法重写的注意事项

      a:父类中私有方法不能被重写

           因为父类私有方法子类根本就无法继承

      b:子类重写父类方法时，访问权限不能更低

             最好就一致

      c:父类静态方法，子类也必须通过静态方法进行重写

           其实这个算不上方法重写，但是现象确实如此，至于为什么算不上方法重写，多态中我会讲解(静态只能覆盖静态)

子类重写父类方法的时候，最好声明一模一样。

9. 方法重写的面试题

      Override和Overload的区别?Overload能改变返回值类型吗?

overload可以改变返回值类型,只看参数列表

      方法重写：子类中出现了和父类中方法声明一模一样的方法。与返回值有关,返回值必须是一致的

      方法重载：本类中出现的方法名一样，参数列表不同的方法。与返回值无关。

子类对象调用方法的时候：先找子类本身，再找父类。

10. final关键字修饰类,方法以及变量的特点

final修饰特点

      修饰类，类不能被继承

      修饰变量，变量就变成了常量，只能被赋值一次

      修饰方法，方法不能被重写

final关键字修饰局部变量

基本类型，是值不能被改变

      引用类型，是地址值不能被改变,对象中的属性可以改变

final修饰变量的初始化时机:S在对象构造完毕前即可