Java基础-面向对象小知识（上）

JavaSE的基础内容基本已学习完毕了，感觉这些java基础就差面向对象这部分没写过了，于是回过头来将面向对象的一些知识点总结下。

 

面向对象思想概述

面向对象和面向过程

在了解面向对象之前我们需要了解下什么是面向过程。

面向过程重点在过程，第一步，第二步，第三步。就如搭积木一般，一块两块三块搭接而成。

那什么是面向对象？

面向对象重点在对象，在面向对象里面就封装了面向过程这些步骤，这些一步两步三步都被封装在对象里了，我们只需要调用（找）这个对象，对象会调用这些封装的方法

简单例子：

买煎饼果子（面向对象）：

首先，你要找到卖煎饼果子的老大妈（准备原料，制作...），然后给钱买，最后开吃。

在上述过程中，我们只需找到老大妈这个对象，她给我们煎饼就ok。

煎饼果子（面向过程）：

1.学习如何摊煎饼    2.准备原料   3.开始制作   4.吃   5.收拾

在上面的面向过程中，就不是找对象了，而是一切的东西都自己来解决，自己来制定这一步干嘛，下一步干嘛。

可以发现，对于调用者来说，面向过程是不是简单多（交给指定对象），而面向过程就复杂多了（每一步都需要自己考虑）

在网上看到一个面向对象和面向过程简单表示：

面向对象： 狗.吃(屎)

面向过程： 吃.(狗,屎)

面向对象思想特点

面向对象是一种更符合我们思想习惯的思想（自己不做，给别人做，轻松），可以将复杂的事情简单化（对于我们而言简单化，而对象内部是十分复杂的），将我们从执行者变成了指挥者（角色发生了转换）

面向对象开发

就是不断的创建对象，使用对象，指挥对象做事情。原则是如果有对象，就直接用对象，对我们进行服务，无对象则开始创建对象。

面向对象设计

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

面向对象特征

封装(encapsulation)     继承(inheritance)     多态(polymorphism)

 

类与对象概述

学习编程是为了什么？就是为了把我们日常生活中实物用学习语言描述出来。

那么我们如何描述现实世界事物

属性    就是该事物的描述信息(事物身上的名词)

行为    就是该事物能够做什么(事物身上的动词)

Java中最基本的单位是类,Java中用class描述事物也是如此

成员变量    就是事物的属性

成员方法    就是事物的行为

类和对象的概念

类：是一组相关的属性和行为的集合

对象：是该类事物的具体体现

举个栗子：一个班上有四五十来个学生，这些学生都具备姓名，年龄，性别，学习，睡觉。既然大家都具备这些共同的属性和行为，那么可以管这些学生都叫做一个学生类。

而每一个同学都是则是一个具体对象，每个人的姓名呀，学习习惯，睡觉习惯都不太相同。

 

通过上面的学习，我们来定义一个手机类：

属性:品牌(brand)价格(price)

行为:打电话(call),发信息(sendMessage)玩游戏(playGame)

 

public class Phone {
	String brand;					//品牌
	int price;						//价格

	public void call() {			//打电话
		System.out.println("打电话");
	}

	public void sendMessage() {		//发信息
		System.out.println("发信息");
	}

	public void playGame() {		//玩游戏
		System.out.println("玩游戏");
	}
}

 

 

 

成员变量和局部变量

两者区别

A:在类中的位置不同

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

B:在内存中的位置不同

成员变量：在堆内存(成员变量属于对象,对象进堆内存)
局部变量：在栈内存(局部变量属于方法,方法进栈内存)

C:生命周期不同

成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失

D:初始化值不同

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

注意事项：

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

基本数据类型变量包括:byte,short,int,long,float,double,boolean,char

引用数据类型变量包括:数组,类,接口,枚举

封装

封装概述

是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

封装好处

隐藏实现细节，提供公共的访问方式；提高了代码的复用性；提高安全性。

封装原则

将不需要对外提供的内容都隐藏起来。把属性隐藏，提供公共方法对其访问。

private关键字特点

是一个权限修饰符，可以修饰成员变量和成员方法，被其修饰的成员只能在本类中被访问。

private仅仅是封装的一种体现形式,不能说封装就是私有。

修改上述的Phone,将成员变量用private修饰，提供对应的getXxx()和setXxx()方法。

 

public class Phone {
	private String brand;					//品牌
	private int price;						//价格
	
	public String getBrand() {
		return brand;
	}
	public void setBrand(String brand) {
		this.brand = brand;
	}
	public int getPrice() {
		return price;
	}
	public void setPrice(int price) {
		this.price = price;
	}
	
	public void call() {			//打电话
		System.out.println("打电话");
	}

	public void sendMessage() {		//发信息
		System.out.println("发信息");
	}

	public void playGame() {		//玩游戏
		System.out.println("玩游戏");
	}
}

 

 

 

构造方法

概述和作用

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

格式特点

方法名与类名相同；没有返回值类型，连void都没有；没有具体的返回值return;

重载及注意事项

重载:方法名相同,与返回值类型无关(构造方法没有返回值),只看参数列表

如果我们没有给出构造方法，系统将自动提供一个无参构造方法；如果我们给出了构造方法，系统将不再提供默认的无参构造方法（建议自己永远给出无参构造方法）

 

了解mian方法

格式：

 

public static void main(String[] args) {}

针对格式的解释：

 

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

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

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

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

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

 

代码块

代码块概述

在Java中，使用{}括起来的代码被称为代码块

代码块分类

根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块（这个可以看看多线程：点此传送门）

代码块的应用

 

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

 

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

 

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

看如下代码，写出其结果：

 

class Student {
    static {
        System.out.println("Student 静态代码块");
    }

    {
        System.out.println("Student 构造代码块");
    }

    public Student() {
        System.out.println("Student 构造方法");
    }
}

class Demo {
    static {
        System.out.println("Demo 静态代码块");
    }

    public static void main(String[] args) {
        System.out.println("我是main方法");

        Student s1 = new Student();
        Student s2 = new Student();
    }
}

结果：

 

 

Demo 静态代码块
我是main方法
Student 静态代码块
Student 构造代码块
Student 构造方法
Student 构造代码块
Student 构造方法

 

 

 

继承

让类与类之间产生关系,子父类关系

继承的好处:

提高了代码的复用性;提高了代码的维护性;让类与类之间产生了关系，是多态的前提

继承的弊端:

类的耦合性增强了。

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

耦合：类与类的关系

内聚：就是自己完成某件事情的能力

Java中类的继承特点

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

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

注意事项

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

子类不能继承父类的构造方法，但是可以通过super关键字去访问父类构造方法

继承中的构造方法：

子类中所有的构造方法默认都会访问父类中空参数的构造方法。因为子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化。

其实，每一个构造方法的第一条语句默认都是：super() Object类最顶层的父类

 

this和super

this:代表当前对象的引用,谁来调用我,我就代表谁

super:代表当前对象父类的引用

两者的区别：

调用成员变量

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

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

调用构造方法

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

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

调用成员方法

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

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

看以下程序，写出结果：

 

class Fu{
    public int num = 10;
    public Fu(){
        System.out.println("fu");
    }
}
class Zi extends Fu{
    public int num = 20;
    public Zi(){
        System.out.println("zi");
    }
    public void show(){
        int num = 30;
        System.out.println(num);
        System.out.println(this.num);
        System.out.println(super.num);
    }
}
class Demo {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show();
    }
}

结果：

 

 

fu
zi
30
20
10

 

 

 

方法重写

重写:子父类出现了一模一样的方法(返回值类型可以是子父类）

应用：

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

注意事项：

1.父类中私有方法不能被重写，因为父类私有方法子类根本就无法继承

2.子类重写父类方法时，访问权限不能更低，最好就一致

Q：Override（重写）和Overload（重载）的区别?Overload能改变返回值类型吗?

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

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

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

final关键字

final修饰特点：

修饰类，类不能被继承

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

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

 

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

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

 

final修饰变量的初始化时机

显示初始化

在对象构造完毕前都可

package关键字

为什么要有包？

将字节码(.class)进行分类存放
包其实就是文件夹

 

/*
 * 方案1：按照功能分 
 * com.info.add 
 * 		AddStudent AddTeacher 
 * com.info.delete 
 * 		DeleteStudent DeleteTeacher 
 * com.info.update 
 * 		UpdateStudent UpdateTeacher 
 * com.info.find
 * 		FindStudent FindTeacher
 * 
 * 方案2：按照模块分 
 * com.info.teacher 
 * 		AddTeacher DeleteTeacher UpdateTeacher FindTeacher 
 * com.info.student 
 * 		AddStudent DeleteStudent UpdateStudent FindStudent
 */

定义包的格式：

 

package 包名;多级包用.分开即可

注意事项：

package语句必须是程序的第一条可执行的代码

package语句在一个java文件中只能有一个

如果没有package，默认表示无包名

带包的类编译和运行：

javac编译的时候带上-d即可

 

javac -d . HelloWorld.java

通过java命令执行

 

 

java 包名.HellWord

 

import关键字

为什么要有import？

让有包的类对调用者可见,不用写全类名了

导包格式：

import 包名.类名;

import 包名.*;

* 代表通配符，会到该包下挨个匹配，匹配上就导入（效率问题）

Q：package,import,class有没有顺序关系

有，package必须放在第一位，import必须放在class前面，class最后

 

权限修饰符

这里的默认相当于包访问权限

 

/*
 * 修饰符： 
 * 		权限修饰符：private，默认的，protected，public 
 * 		状态修饰符：static，final 
 * 		抽象修饰符：abstract
 * 
 * 类： 
 * 		权限修饰符：默认修饰符，public 
 * 		状态修饰符：final 
 * 		抽象修饰符：abstract
 * 
 * 成员变量： 
 * 		权限修饰符：private，默认的，protected，public 
 * 		状态修饰符：static，final
 * 
 * 构造方法： 
 * 		权限修饰符：private，默认的，protected，public
 * 
 * 成员方法： 
 * 		权限修饰符：private，默认的，protected，public 
 * 		状态修饰符：static，final 
 * 		抽象修饰符：abstract
 * 
 */