面向对象知识点回顾1

static关键字

概念：多个对象共享同一份数据，是静态的，可以修饰成员变量和成员方法，同时还可以修饰代码块和修饰类,但是必须是内部类。

static关键字特点

1.随着类的加载而加载
2.静态变量属于类不属于对象
3.被类的所有对象共享
4.静态的内容存在于方法区的静态区
5.static是共享的,不变的,放在方法区,静态代码块在类加载的时候 就会执行,并且只执行一次

static的使用

1.可以通过类名调用
2.类名.静态变量
3.类名.静态方法
4.通过读写方法访问

static关键字应用场景

• 不想创建某个类的对象，而希望直接访问该类的某些属性或方法。

static关键字注意事项

1.在静态方法中是不能使用this和super关键字。
2.静态方法只能访问静态的成员变量和静态的成员方法。
3.全是静态方法的类一般在开发当中被看做工具类，例如Math类、Arrays 工具类。
4. 非静态环境可以访问静态变量

static关键字主要有四种用法：

1.用来修饰成员变量，将其变为类的成员，从而实现所有对象对于该成员的共享；

2.用来修饰成员方法，将其变为类方法，可以直接使用“类名.方法名”的方式调用，常用于工具类；

3.静态块用法，将多个类成员放在一起初始化，使得程序更加规整，其中理解对象的初始化过程非常关键；

4.静态导包用法，将类的方法直接导入到当前类中，从而直接使用“方法名”即可调用类方法，更加方便。

静态修饰方法的意义

1.简化代码

2.静态方法用来访问静态成员

3.编写工具类

• 构造方法私有
• 成员方法添加static关键字修饰

代码块

代码块

1.概念:使用”{}”括起来的一段代码

2.分类：根据位置可分类

• 普通代码块：直接在方法或语句中定义的代码块

• 局部代码块: 定义在局部位置,限定局部变量的作用域

• 构造代码块：定义在成员位置，直接写在类中的代码块，抽取多个构造代码块的重复代码,从而简化代码

• 静态代码块：定义在成员位置，在类加载的时候执行,只能够执行一次

• 同步代码块：定义在局部位置

静态变量和非静态变量的区别

1.构造方法、构造代码块、静态代码块的执行顺序：静态代码块 > 构造代码块 > 构造方法

2.静态代码块在类加载的时候执行只执行一次

3.构造代码块在每次访问构造方法之前执行,可以执行多次

4.构造方法每次创建对象的时候执行,可以执行多次

包

包的概述

• 本质就是文件夹
• 分门别类地管理Java文件
• 处理同一个文件夹中类名重名的问题

包的声明:
package 包名1.包名2…;

包的导入:
import java.util.Scanner;

包的特点:
1.同包下的类相互调用不需要导入

2.在同一个类中使用不同包中的同名类,需要显示导入,例如Date
ava.util.Date date = new java.util.Date();

3.如果一个类没有包,那么默认在default包下,该包下的类永远无法被外界访问,只能够在同包下访问

4.包的声明必须出现在Java文件的第一句

5.如果希望导入一个包中所有的类 java.util.*;

6.java.lang(核心包)包下的类不需要导入

7.在写一个类的时候千万不要和系统的类重名

JDK中常用的包:
1.java.lang 包含了Java中一些核心的包 String Object Math Arrays

2.java.awt: 包含了Java中一些窗口图形化的相关类

3.java.util: 工具包

4.java.net: 网络包

5.java.io: 输入输出流

super关键字

this和super用法类似，this代表本类引用，super代表父类父类引用。

this和super的对比使用

1.访问成员变量
this.成员变量 super.成员变量

2.访问构造方法
this()：访问本类无参构造 this(参数列表) 访问本类带参构造
super()：访问父类无参构造 super(参数列表)：访问父类带参构造

3.访问成员方法
this.成员方法()：访问本类成员方法
super.成员方法()：访问父类成员方法

this和super的区别

1.this可以理解为当前对象,谁调用this就代指那个调用者对象,

2.每次创建一个对象,默认都会创建一个this变量指向同一个堆区空间

3.super本质是父类存储空间的标识,但是你可以理解为父类对象,
那么同样可以使用super这个关键字来访问父类的成员

注意:
1.任何一个类的无参或者带参构造方法的第一句都默认省略 super();

2.任何一个类都直接或者间接继承自Object类

3.为什么设计Object类,满足了万事万物皆对象的原则
访问根类Object的无参构造方法的意义何在? - 加载Object类中静态成员和静态代码块

4.创建一个子类对象默认会去调用父类的构造方法,那么有没有在创建子类对象的同时也创建了父类对象呢?
没有创建父类对象,本质就相当于访问了一个普通方法,创建对象开启空间需要new关键字

5.super访问父类带参构造方法的意义? – 帮助子类初始化父类继承下来的成员,简化编程

6.静态环境/静态上下文(static修饰的方法),不能够出现this和super

7.super必须出现在构造方法的第一句

8.this和super不能够共存

继承

概念:

• 类是对一批对象的抽象,继承是对一批类的抽象

继承的格式:
类和类之间的关系:

• 继承 (is a)
• 组合 (has a)
• 通过extends关键字可以实现类与类的继承
• class 子类类名 extends 父类类名 { }
• 被继承的这个类称为父类，基类或者超类
• 继承的这个类称为子类或者派生类

继承的特点:

• 1.通过extends关键字,实现了继承之后,让类与类之间产生了关系,建立关系是好还是坏? 有好友坏
• 2.继承的本质就是抽取共性代码,多个重复代码的向上抽取,简化代码 BaseDao BaseActivity
• 3.类是对一批对象的抽象,继承是对一批类的抽象
• 4.父类又被称为超类,或者基类,子类又被称为派生类
• 5.Java是面向对象语言,万事万物皆是对象,为了满足这个设计原则,所有的类都直接或者间接继承自Object类

继承的好处:

• 1.简化了代码
• 2.提高了扩展性
• 3.提高了可维护性
• 4.开闭原则: 对扩展开放,对修改关闭

继承的缺点:

• 开闭原则: 对扩展开放,对修改关闭
• 高内聚,低耦合: 类与类之间,功能与功能之间,模块与模块之间,功能尽量内聚,不同模块之间,尽量独立
• 造成了耦合性过高,牵一发动全身
• 注意: 继承一定要慎用,主要利用继承简化代码的优点

继承的注意事项:

• 1.单一继承性
• 2.支持多层继承
• 3.如果父类成员使用private修饰,那么子类不能被继承
• 4.如果一个子类继承了父类的属性和方法还可以有自己特有的属性和方法
• 5.当子类和父类的成员变量重名的时候,子类优先
• 6.构造方法不能够被继承

如何使用继承

• 1.一般在写代码的时候发现代码中存在重复代码,需要向上抽取,考虑继承
• 2.当某个类的设计非常复杂的时候可以考虑继承 例如: 设计一个窗口类

使用继承的步骤:

1、书写出所有子类，观察子类共有的成员变量和成员方法

2、抽象出共同点，书写一个父类

3、让子类去继承父类，并把子类的共有属性删除

访问权限修饰符

访问权限修饰符：
public [default] protected private

修饰类
1.public 任何包中的类都可以访问该类
2.默认(default) 同一个包中的类可以访问该类
3.不能用protected和private修饰类。

修饰成员（成员变量或者成员方法）
1.private 只对本身类可见
2.默认(default) 对同一包中的类可见
3.protected 对所有子类和同一包中的类可见
4.public 对一切类可见

方法重写

方法重写概述

如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。子类中出现了和父类中一模一样的方法声明，也被称为方法覆盖，方法复写

方法重写的规则

1.发生在具有子父类的两个类中

2.方法名相同

3.参数列表相同

4.返回值类型相同或者是其子类

5.访问权限不能严于父类

6.抛出的异常不能够被扩大

访问权限修饰符的宽严关系
public > protected > default > private

方法重写的注意事项
1、父类中private修饰的方法不能被重写，也不能够被继承。
2、构造方法不能被重写。
3、子类重写父类方法时，访问权限不能更低。
4、重载和重写的比较(重写和重载是完全不同的两个概念毫无任何关系)
5、返回值类型相同或者是其子类

举例：
有农民(farmer)，教师(teacher)，科学家(scientist)，服务生(attendant)，其中农民，服务生只有基本工资，教师除基本工资外，还有课酬(元/天),科学家除基本工资外,还有年终奖，请你写出相关类，将各种类型的员工的全年工资打印出来。

public class OverrideDemo {
	public static void main(String[] args) {
		Farmer f = new Farmer(4500.0);
		Teacher t = new Teacher(6000.0, 60);
		Scientist s = new Scientist(8000.0, 100000.0);
		Attendant a = new Attendant(2400.0);

		f.printAllYearSalary();
		t.printAllYearSalary();
		s.printAllYearSalary();
		a.printAllYearSalary();
	}
}

class Employee {
	protected double basicSalary;

	public Employee() {
	}

	public Employee(double basicSalary) {
		this.basicSalary = basicSalary;
	}

	public void printAllYearSalary() {
		System.out.println("全年工资: " + (basicSalary * 12));
	}

	public double getBasicSalary() {
		return basicSalary;
	}

	public void setBasicSalary(double basicSalary) {
		this.basicSalary = basicSalary;
	}

}

class Farmer extends Employee {

	public Farmer() {
	}

	public Farmer(double basicSalary) {
		super(basicSalary);
	}
}

class Teacher extends Employee {
	private double courseFee;

	public Teacher() {
	}

	public Teacher(double basicSalary, double courseFee) {
		super(basicSalary);
		this.courseFee = courseFee;
	}

	public double getCourseFee() {
		return courseFee;
	}

	public void setCourseFee(double courseFee) {
		this.courseFee = courseFee;
	}

	@Override
	public void printAllYearSalary() {
		System.out.println("全年工资: " + (basicSalary * 12 + courseFee * 600));
	}
}

class Scientist extends Employee {
	private double yearBouns;

	public Scientist() {
	}

	public Scientist(double basicSalary, double yearBouns) {
		super(basicSalary);
		this.yearBouns = yearBouns;
	}

	@Override
	public void printAllYearSalary() {
		System.out.println("全年工资: " + (basicSalary * 12 + yearBouns));
	}

	public double getYearBouns() {
		return yearBouns;
	}

	public void setYearBouns(double yearBouns) {
		this.yearBouns = yearBouns;
	}
}

class Attendant extends Employee {
	public Attendant() {
	}

	public Attendant(double baiscSalary) {
		super(baiscSalary);
	}
}