黑马程序员---基础-概述、封装、构造方法、this和static关键字、继承

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-

一、面向对象概述

1.类实质上就是封装对象属性和行为的载体，类是同一类事物的统称。

2.对象是类抽象出来的一个实例（万物皆对象），该类是事物实实在在的个体。

3.面向对象的三大特点：①封装；②继承；③多态。

（1）面向对象的特点：

1.是一种更符合我们思想习惯的思想

2.可以将复杂的事情简单化

3.将我们从执行者变成了指挥者，角色发生了转换

我们在解决问题的时候，就是找对象，如果没有对象，就创造对象去解决方法。

我们描述小汽车的时候，有轮胎数、颜色，这些是事物的属性；还有汽车的运行，这些是事物的行为。我们在定义类的时候，就是定义类中的成员，其中成员变量对应着事物的属相，成员方法对应着事物的行为。

如我们可以定义一个Car类就可以这样：

class Car{
int num;//车的轮胎数
String color;//车的颜色
void run(){
System.out.println(num+"..."+color);
}
}

（2）成员变量和局部变量的区别

主要是四个方面的区别：

A:在类中的位置不同

成员变量：在类中方法外

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

B:在内存中的位置不同

成员变量：在堆内存

局部变量：在栈内存

C:生命周期不同

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

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

D:初始化值不同

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

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

下面举个例子：

// 基本类
class Variable {

int num = 40;

public void show(){

// 错误的: 可能尚未初始化变量num2
// int num2 ;
/*
int num2 = 20;
System.out.println(num2);
*/

// int num = 30 ;
System.out.println(num);
}

}

// 测试类
class VariableDemo {

public static void main(String[] args){

// 创建对象
Variable v = new Variable();

// System.out.println(v.num);

// 调用show方法
v.show();

}

}

程序执行的结果是：



二、封装

封装的引入就是为了隐藏实现细节，保证一些数据的安全。仅对外提供公共的方法对其访问。

（1）封装的好处

①隐藏实现细节，提供公共的访问方式

②提高了代码的复用性

③提高安全性。

（2）具体的实现

// 学生类
class Student {

// 成员变量
String name ;// 姓名
private int age ;// 年龄

// 定义一个方法来给age赋值
public void setAge(int a){  // -18
if(a < 0 || a > 120){
System.out.println("你输入的年龄不正确");
}else{
age = a ;
}
}

// 成员方法
public void show(){
System.out.println(name);
System.out.println(age);
}
}

// 测试类
class StudentDemo {

public static void main(String[] args){

// 创建学生对象
Student s = new Student();

// 给成员变量赋值
s.name = "小红";
// s.age  = 18 ;
s.setAge(18);

// 调用show方法输出所有的成员变量
s.show();

System.out.println("--------------------");

// 创建学生对象
Student s1 = new Student();

// 给成员变量赋值
s1.name = "小花";
// s1.age = -18;
s1.setAge(-18);

// 调用show方法输出所有的成员变量
s1.show();

}

}

程序执行的结果是：



三、this关键字

我们之前说过: 起名字要做到”见名知意”，我们在方法中使用参数赋值的时候就可以使用this关键字来代表本类对象的引用。也就是说谁调用方法,这个方法中的this代表的就是谁。

下面是具体的代码实现：

// 定义一个学生类
class Student {

// 成员变量
private String name ;       // 姓名
private int     age ;       // 年龄

// 提供对应的get和set方法
public String getName(){
// return name ;            // 存在一个隐含的this
return this.name ;
}

public void setName(String name){

// 我们变量的访问遵循一个"就近原则"
// 我们需要的是将传递进来的name赋值给成员变量的name
// name = name ;

// 我们要访问成员变量需要使用对象对其访问,那么谁又可以代表当前类的一个对象呢?
// 这时候java就给我们提供了一个关键字: this
this.name = name ;
}

public int getAge(){
return age ;
}

public void setAge(int age){
this.age = age ;
}

}

// 测试类
class StudentDemo {

public static void main(String[] args){

// 创建学生对象
Student s = new Student();

// 给成员变量赋值
s.setName("小菲菲");
s.setAge(13);

// 输出所有的成员变量
System.out.println(s.getName() + "---" + s.getAge());

// 创建学生对象
Student s1 = new Student();

// 给成员变量赋值
s1.setName("大菲菲");
s1.setAge(18);

// 输出所有的成员变量
System.out.println(s1.getName() + "---" + s1.getAge());

}

}

程序执行的结果是：



四、构造方法

构造方法就是创建对象,给对象中的成员进行初始化用的。

※构造方法的格式特点

a:方法名与类名相同

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

c:没有具体的返回值

下面举个例子可以看看：

// 手机类
class Phone {

// 成员变量
private String brand ;      // 品牌
private String color ;      // 颜色
private int    price ;      // 价格

// 构造方法
public Phone(){}

public Phone(String brand , String color , int price){
this.brand = brand ;
this.color = color ;
this.price = price ;
}

// 提供get和set方法
public String getBrand(){
return brand ;
}

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

public String getColor(){
return color ;
}

public void setColor(String color){
this.color = color ;
}

public int getPrice(){
return price ;
}

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

}

// 测试类
class PhoneDemo {

public static void main(String[] args){

// 创建手机对象方式1
Phone p = new Phone();

// 给成员变量赋值
p.setBrand("苹果");
p.setColor("白色");
p.setPrice(100);

// 获取成员变量
System.out.println(p.getBrand() + "---" + p.getColor() + "---" + p.getPrice());

System.out.println("----------------------------------");

// 创建手机对象方式2
Phone p2 = new Phone("三星" , "黑色" , 50);

// 获取成员变量
System.out.println(p2.getBrand() + "---" + p2.getColor() + "---" + p2.getPrice());

}

}

程序执行的结果是：



看过上面的例子后，我们还需要注意两个事项：

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

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

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

五、static关键字

这里先讲讲static关键字的特点

1.随着类的加载而加载

2.优先于对象存在

3.被类的所有对象共享。举例：咱们班级的学生应该共用同一个班级编号。其实这个特点也是在告诉我们什么时候使用静态?如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的。

4.可以通过类名调用，其实它本身也可以通过对象名调用。推荐使用类名调用。静态修饰的内容一般我们称其为：与类相关的，类成员

程序：

// 人类
class Person {

// 成员变量
String name ;           // 姓名
// String country ;     // 国籍

static String country ;

public void show(){
System.out.println(name + "---" + country);
}
}

// 测试类
class PersonDemo {

public static void main(String[] args){

// 创建一个对象
Person p = new Person();

// 给成员变量赋值
p.name = "凤姐";
p.country = "中国";

// 调用show方法
p.show();

// 创建第二个对象
Person p2 = new Person();

//给成员变量赋值
p2.name = "刘亦菲";
// p2.country = "中国";

// 调用show方法
p2.show();

System.out.println("-----------------------");

p.country = "美国";
p.show();
p2.show();

}

}

执行的结果是：



六、继承

继承使用extends关键字，它的好处是：

1.提高了代码的复用性；

2.让类与类之间产生了关系，给第三个特征多态提供了前提；

3.提高了代码的维护性；

（1）引出

继承其它类的类叫”子类”，被继承的类叫”父类”、”超类”、”基类”，当子类继承了父类后，就自动拥有了父类中允许被继承的成员；大家可以近似的认为：子类就是拥有了父类中的可以被继承的成员。

如下程序所示：

class Person
{
String name;//姓名
int age;//年龄
char sex;//性别

void show(){
System.out.println("我是传智播客的一员，我骄傲！！");
}
}
//Person的"子类"
class Student extends Person
{
String stuNo;//学员编号
int score;//分数；
}
//Person的"子类"
class Teacher extends Person
{
String teaNo;//教师编号
}
//当再需要"员工类"时，也需要这些成员时，可以直接继承自"Person"
class Employee extends Person
{
//自动拥有了Person的三个属性和一个方法；
}
class Demo
{
public static void main(String[] args)
{
Student stu = new Student();
System.out.println(stu.name);//继承的
System.out.println(stu.age);//继承的
System.out.println(stu.sex);//继承的
System.out.println(stu.stuNo);//自己的
stu.show();

Teacher tea = new Teacher();
System.out.println(tea.name);//继承的
System.out.println(tea.age);//继承的
System.out.println(tea.sex);//继承的
System.out.println(tea.teaNo);//自己的
tea.show();

}
}

结果是：



在java中只支持单继承，不支持多继承的，但可以支持多层继承。

（2）继承的注意事项

1.子类不能继承父类中私有成员：

2.构造方法是不能被继承的；

3.当实例化一个子类对象时，会调用父类的构造方法，实例化一个父类对象；这个父类对象，是存储在子类对象空间内的。

4.不要为了部分功能而去继承：

5.当类和类之间是：是一个(is a)的关系时，使用继承，学员是传智播客的一员，教师是传智播客的一员，所以，Student可以继承自Person，Teacher也可以继承自Person

代码：

class A
{
String name;
private int age;//此成员不会被子类继承

private void show(){//此方法不会被子类继承
System.out.println("private的show()");
}

void show2(){
System.out.println("非私有的show2()");
}
A(){
System.out.println("A的构造方法");
}
}
class B extends A
{
B(){
System.out.println("B的构造方法");
}
}
class Demo
{
public static void main(String[] args)
{
B b = new B();
//  System.out.println(b.name);//OK的，name可以被继承
//  System.out.println(b.age);//NO的，编译错误，age私有的，不能被继承

//  b.show();///NO的，编译错误，show私有的，不能被继承
//  b.show2();//OK的，show2可以被继承

B b2 = new B();

}
}

运行的结果是：



（3）继承中成员变量的关系

1.首先在子类局部范围找

2.然后在子类成员范围找

3.最后在父类成员范围找(肯定不能访问到父类局部范围)

4.如果还是没有就报错。(不考虑父亲的父亲…)

class A
{
int num = 10;
}
class B extends A
{
int a = 20;
int num = 30;//子类成员变量，覆盖父类的成员变量；

void show(){
//就近原则；
int num = 40;//局部变量，覆盖成员变量
System.out.println("num = " + num);//40 注意：先找局部，再找成员，再找父类；
System.out.println("this.num = " + this.num);//30，注意：如果本类没有，会向父类去找；
System.out.println("super.num = " + super.num);//访问父类的num : 10
}
}
class Demo
{
public static void main(String[] args)
{
B b = new B();
//在外部访问B中的成员变量
/*
System.out.println(b.num);
System.out.println(b.a);
*/
b.show();
}
}

结果是：