第一周预习-java面向对象

第二章 java面向对象

一、设计对象并使用

面向对象三大特征：封装，继承，多态。

1.1-类和对象

• 类：是对象共同特征的描述；
• 对象：是真实存在的具体东西。

在Java中，必须先设计类，才能获得对象。

定义类

一个类中包括成员变量，成员方法，构造器，代码块，内部类。

publivc class Phone{      //"Phone"是类名
	String brand;    
	double price;
						  //"brand"和"price"是属性（成员变量）
	public void call(){
	
	}
	public void playgame(){
	
	}
						  //"call"和"playgame"是行为（方法）
}

得到类的对象

类名 对象名 = new 类名( );

Phone p = new Phone();

使用对象

• 访问属性：对象名.成员变量
• 访问行为：对象.方法名(…)

1.2-定义类的注意事项

类的种类

• Javabean类：用来描述一类事物的类,Javabean类中不写main方法。
• 测试类：编写main方法的类。

类的定义格式注意事项

• 类名首字母建议大写，驼峰模式起名。

• 一个Java文件中可以定义多个class类，但只能有一个类是public修饰。

• public修饰的类名必须是代码文件名。

• 成员变量的完整定义格式：修饰符 数据类型 变量名称 = 初始化值；

  注意：成员变量不初始化会有默认值，一般不初始化值。

对象变量的默认值

数据类型	明细	默认值
整数类型	byte、short、int、long	0
浮点类型	float、double	0.0
布尔类型	boolean	false
引用类型	类、接口、数组、String	null

基本数据类型与引用数据类型

基本数据类型：数据值是存储在自己的空间中。

特点：赋值给其他变量，也是赋的真实的值

引用数据类型：数据值是储存在其他空间中，自己空间中存储的是地址的值。

特点：赋值给其他变量，赋的地址值。

二、封装

2.1-什么是封装

对象代表什么，就得封装对应的数据，并提供数据对应的行为。

例如：

人画圆，人关门

圆的半径和门的状态都是圆和门的属性，因此“画圆”和“关门”的方法应该在圆类和门类中定义。

封装的好处

• 使编程变得简单，有什么事，找对象，调方法。

• 同时降低学习成本，使用现成的对象与方法，例如String，Socket等。

2.2-private关键字

private是什么

• 是一个权限修饰符
• 可以修饰成员（成员变量和成员方法）
• 被private修饰的成员只能在本类中才能访问

使用private后如何对成员变量进行赋值与调用

利用setXxx()赋值通道与getXxx()获取通道

例如：

public class GirlFriend {
    private int age;
    	//age被private修饰，只能在本类中被访问
    public void setAge(int a){
        if(a >m 18 && a <= 50){
            age=a;
        }
        else{
            System.out.println("非法数据");
        }
        //使用setAge方法对age进行赋值
        
        public int getAge(){
            return age;
        }
        //使用getAge方法调用age的值
    }
}

注意：尽量不直接使用类名.属性的方法赋值，使用方法进行赋值。

2.3-this关键字

成员变量与局部变量的区别

区别	成员变量	局部变量
类中位置	类中，方法外	方法内、方法申明上
初始化值	有默认初始化值	没有，使用之前需要完成赋值
内存位置	堆内存	栈内存
生命周期	随着对象的创建而存在，随着对象的消失而消失	随着方法的调用而存在，随着方法的运行结束而消失
作用域	整个类中有效	当前方法中有效

就近原则

public class Friend{
    int age;	
    	//age是成员变量
    public void method(){
        int age = 18;
        //在方法中定义的age是局部变量
        System.out.println(age);
        //此时遵循就近原则，输出的age是局部变量
        System.out.println(this.age);
        //使用this关键字，输出的age是成员变量
    }
}

2.4-this的作用与本质

作用：区别成员变量和局部变量

本质：所在方法调用者的地址值

三、构造方法

3.1-构造方法是什么

构造方法也叫构造器、构造函数。

作用：在创建对象的时候，虚拟机会自动调用构造方法，给成员变量进行初始化。

初始化

初始化 = 赋值。

Phone p = new Phone();
//Phone() 括号中什么都没有，即调用的空参的构造方法。

3.2-构造方法的格式

public class Student{
    修饰符 类名(参数){
        方法体;
	}
    
}

特点

• 方法名与类名相同，大小写也一致
• 没有返回值类型，连void都没有
• 没有具体的返回值（不能由return带回结果数据）
• 不定义构造方法，系统会默认有空参的构造方法
• 定义了构造方法，系统就不再提供默认的构造方法

执行时机

• 创建对象的时候有虚拟机调用，不能手动调用构造方法
• 每创建一次对象，就调用一次构造方法

注意：推荐无论是否使用都手动书写构造方法（不论是否带参数)

四、标准JavaBean类

4.1-如何写一个标准的JavaBean类

1. 类名要见名知意，用驼峰命名的方法
2. 成员变量用private修饰
3. 至少提供两个构造方法
   • 无参构造方法
   • 带全部参数的构造方法
4. 成员方法
   • 提供每一个成员的setXxx()/getXxx()
   • 如果还有其他行为，也需要写上

五、继承

5.1-什么是继承

• Java中提供的一个关键字extends，用这个关键字，我们可以让一个类与另一个类建立起继承关系。

public class Student extends Person {}  //Student类继承自Person

• Student称为子类（派生类），Person称为父类（基类或超类）。
• 子类可以得到父类的属性和行为，子类可以使用。

使用继承的好处

• 可以把多个子类中重复的代码抽取到父类中了，提高代码的复用性。
• 子类可以在父类的基础上，增加其他的功能，使子类更强大。

什么时候使用继承

当类与类之间，存在相同（共性）的内容，并满足子类是父类中的一种，就可以考虑使用继承，来优化代码。

5.2子类继承的特点

Java只支持单继承，不支持多继承，但支持多层继承

• 单继承：应该子类只能继承一个父类
• 不支持多继承：一个子类不能同时继承多个父类
• 多层继承：子类A可以继承父类B，父类B可以继承父类C

注意：每一个类都直接或间接的继承于Object类。

子类能继承父类中的哪些内容

内容	非私有	private
构造方法	不能	不能
成员变量	能	能
成员方法	能	不能

注意：private的不能直接使用。

父类的构造方法不能被子类继承：构造方法必须和类名一致，父类的构造方法和子类名不一致，所以不能继承。

子类成员变量的隐藏

编写子类成员变量时声明的成员变量名字与从父类继承来的成员变量名字相同时，子类会隐藏所继承的成员变量。

子类隐藏变量的特点

• 子类继承的方法所操作的对象一定是被子类继承或隐藏的对象
• 子类继承的方法不能操作子类新声明的对象

子类隐藏变量的例子

public class A{
    int Num;
    //父类的Num成员变量
}
public class B extends A{
    int Num;
    //子类定义Num变量，父类Num变量被隐藏
}

子类方法的重写

什么是方法重写

子类继承父类的某个方法，就有权利重写这个方法（不包括final方法）。

子类可以通过方法重写隐藏已继承的方法。

方法重写的特点

• 重写方法的名字、参数个数、参数类型和父类方法完全相同。
• 重写方法既可以操作继承的变量、调用继承的方法，也可以操作子类新声明的成员变量、调用子类新定义的其他方法。

注意：子类重写方法时，不允许降低方法的访问权限，但是可以提高访问权限。

子类重写方法的例子

public class A{
    int Num1;
    public void setNum(int n){	
        Num1=n;
    }
    	//父类中定义setNum方法
}
public class B extends A{
    int Num2;
    public void setNum(int n){
        Num2=n+1;	//操作新声明的Num2变量
    }
    	//子类中重写setNum方法，名字、参数个数、参数类型和父类方法完全相同
}

5.3-super关键字

操作被隐藏的成员变量和方法

在子类中想使用被子类隐藏的变量和方法，要使用super关键字，例如super.x、super.setName()，就是访问被子类隐藏的成员变量x和方法setName。

public class A{
    int Num;
    public int setNum(int n){	
        n=n+1;
        return n;
    }
    	
}
public class B extends A{
    int Num;
    public int setNum(int n){
        super.Num=super.setNum(n);
        //super调用的是子类隐藏父类中的成员变量Num与方法setNum
        //Num=n+1
        Num=n;
        //子类新声明的Num=n
        System.out.println(super.Num);//输出n+1
        System.out.println(Num);	  //输出n
        return 1;
    }
    	
}

使用super调用父类的构造方法

• 子类不继承父类的构造方法
• 子类在其构造方法中需要使用super来调用父类的构造方法（给父类中的变量初始化）
• super必须是子类构造方法中的第一个语句
• 编译器默认提供无参super()，如果显式地写出super关键字调用父类的某个构造方法则不再默认提供

5.4-final关键字

final类

用final关键字声明final类，表明该类为最终类，final类不能被继承，即不能有子类。

fina class A{			//A类不能有子类
    ......  	
}

final方法

用final修饰父类中的一个方法，则该方法不能被子类重写。

public class A{
    int Num;
    public final void setNum(int n){	
        .....	//final定义后setNum方法不能被重写
    }
}
public class B extends A{
    int Num;
    ..... 	  	//子类定义方法不能重新setNum
}

常量

用final修饰成员变量或者局部变量，则变量就变为常量。

public class A{
    final int Num;
    public final void setNum(int n){	
       	//Num=n+1; //非法，不允许对final变量进行更新操作
        return Num+1;
    }
}

六、多态

6.1-上转型对象

什么是上转型对象

例如：老虎是动物，假设Animal类是Tiger的父类

Animal a;
a = new Tiger();

或者

Animal a;
b = new Tiger();
a = b;

这时可称对象a是对象b的上转型对象（老虎是动物）。

上转型对象的特点

上转型对象是一简化的子类对象，失去了子类的一些属性和功能。

• 上转型对象不能访问子类新增的成员变量，不能调用子类新增的方法
• 上转型对象可以访问子类继承或隐藏的成员变量，也可以调用子类继承或重写的方法
• 可以将上转型对象强制转换回子类对象
• 然后子类重写了父类的静态方法，则上转型对象不能调用子类重写的静态方法，只能调用父类的静态方法

6.2-什么是多态

多态性就是指父类的某个方法被其子类重写时可以各自产生自己的功能行为，即同类型的对象，表现出的不同形态。

多态的表现形式

父类类型 对象名称 = 子类对象

多态的前提

• 有继承关系
• 有父类引用指向子类对象
• 有方法重写

多态中的调用

多态的对象是一种上转型对象，要遵循上转型对象的特点。

• 变量调用：编译看左边（父类中是否有该变量），运行也看左边（实际获取父类中该变量）
• 方法调用：编译看左边（父类中是否有该方法），运行看右边（实际调用子类中重写的方法）

多态的优劣

优：方法中，使用父类型为参数，可以接受所有子类对象，便于拓展和维护

劣：不能使用子类的特有功能

6.3-什么是接口

待补充······