Java笔记 面向对象的三大特性 封装 private 继承 extends static super abstract final多态 向上转型 向下转型

封装

定义

将类的某些信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问

原则

1、把所有的属性藏起来
2、把尽可能多地东西藏起来，对外提供便捷的接口

实现封装的步骤

1、修改属性的可见性：设为private，防止错误的修改
2、创建共有的getter/setter方法：用于属性的读写
3、在getter/setter方法中加入属性控制语句：对属性值得合法性进行判断

封装的好处：

1、便于使用者正确使用系统，防止错误修改属性
2、有助于系统之间的松耦合，提高系统的独立性
3、提高软件的可重用性
4、降低了构建大型系统的风险

**注意：**用private修饰的属性和方法在本类中可以直接访问，在其他类中无法直接访问。
例如：将属性值进行封装，使得在本类外的时候调用，无法直接设置或者调用，只能通过set或者get设置或者获取本类中封装的属性【在封装的get\set方法中我们可以进行各种限制，比如说健康值不能大于100，不能小于0】

public class Pet{
	private String name;//名字
	private int health;//健康值
	private int love;//亲密度
	
	public Pet() {//无参构造方法
		super();
	}
	public Pet(String name, int health, int love) {//有参构造方法
		super();
		this.name = name;
		this.health = health;
		this.love = love;
	}
	
	public String getName() {//获取名字
		return name;
	}
	public void setName(String name) {//设置名字
		this.name = name;
	}
	public int getHealth() {//获取健康值
		return health;
	}
	public void setHealth(int health) {//设置健康值
		Scanner input = new Scanner(System.in);
		while(health<0||health>100){
			System.err.println("健康值只能在0~100之间，青重新输入：");
			health = input.nextInt();
		}
		this.health = health;
	}
	public int getLove() {//获取亲密度
		return love;
	}
	public void setLove(int love) {//设置亲密度
		this.love = love;
	}
}

包

包作用

1、允许类组成较小的单元（类似文件夹，易于找到和使用相应的文件）
2、防止命名冲突区分名字相同的类
3、有助于实施访问权限控制

JDK提供的三个基本包

1、java.lang：虚拟机自动引入
2、java.util:提供一些实用类
3、java.io:输入、输出

使用MyEclipse创建包的两种办法

1、分别创建包和类
2、创建类的过程中创建类所在的包

创建包的规范

1、报名有小写字母组成，不能以圆点开头或结尾
2、包名之前最好加上唯一的前缀，通常使用组织倒置的网络域名
3、包名后续部分依不同机构内部的规范不同而不同

包的声明

语法：package 包名;
1、作为java源代码第一条非注释型语句
2、用package声明包，以分号结束

包导入语句

import 包名.类名
Myeclipse导包的快捷键：Ctrl+Shift+O

注意事项：
1、一个类同时引用两个来自不同包的同名类：必须通过完整类名来区分
2、每个包都是独立的顶层包不会包含子包的类
3、package和import的顺序是固定的
（1）package必须位于第一行（忽略注释行）
（2）只允许有一个package语句
（3）其次是import
（4)接着是类的声明

访问权限控制

类的访问修饰符：public、default（默认）
	1、public修饰符：共有访问级别
	2、默认修饰符：包级私有访问级（只有本包的类可以访问）

修饰符	同一类中	同一包中	子类中	任何地方
private	√	×	×	×
默认修饰符	√	√	×	×
protected	√	√	√	×
public	√	√	√	√

static修饰

1、成员变量：静态变量或类变量，可以直接通过类名访问【此时的成员变量可以划分为两种：静态变量和实例变量】   静态变量可以直接通过类名去调用【类名.变量名】
2、成员方法：静态方法或类方法，【此时的成员方法可以划分为两种弄：静态方法和实例方法】静态方法也可以直接通过类名访问【类名.方法名()】
3、代码块：静态代码块，当java虚拟机加载类时，就会执行改static代码块：在加载类的时候加载，并且只加载一次

静态方法：可以直接通过类名来访问
1、静态方法中不能使用this和super
2、不能直接访问所属类的实例变量和实例方法【因为加载时间不同】
3、可以直接访问类的静态变量和静态方法

public class StaticTest {
	int num1 = 100;
	public static int num = 10;
	static{//创建静态方法块，在类加载的时候执行静态代码块中的代码
		System.out.println("静态方法块！");
	}
	public static void main(String[] args) {
		
		System.out.println(StaticTest.num);//可以直接用类名直接访问
		StaticTest test = new StaticTest();//创建对象
		System.out.println(test.num1);//普通成员变量，需要创建对象，用对象名进行调用
		StaticTest test1 = new StaticTest();
		test1.num1 = 200;
		test1.num = 20;
		//实例变量创建对象，不同对象中变量的改变不影响其他对象中的变量，是因为在创建对象的时候，重新为这个对象重新开辟一个内存空间
		System.out.println("test中的num1:"+test.num1);
		System.out.println("test1中的num1:"+test1.num1);		
		System.out.println("*************************");
		//静态变量是随着类的加载而加载，但是静态变量不会一直保留,如果遭到改变就会被彻底改变
		System.out.println("test中的num:"+test.num);
		System.out.println("test1中的num:"+test1.num);
	}
}

实例方法

通过实例访问
1、可直接访问所属类的静态变量、静态方法、实例变量和实例方法
静态方法必须被实现（不能作为抽象方法）

继承

继承的作用

extends【1、减少代码量；2、方便修改代码】

原则

继承是Java中实现代码重用的重要手段之一。Java中只支持单根继承，即一个类只能有一个直接父类

如何使用继承：

1、编写父类
	[访问修饰符] class Pet{
		//公共属性和方法
	}
2、编写子类，继承父类
	[访问修饰符] class Dog extends Pet{
		//子类特有的属性和方法
	}

子类继承父类什么

1、继承public和protect修饰的属性和方法，不管子类和父类是否在同一个包中
2、继承默认权限修饰符（default）的属性和方法，单子类和父类必须在同一个包中

子类不能继承父类什么

1、private成员
2、子类与父类不在同包，使用默认访问权限的成员
3、构造方法不能被继承，但是可以调用

方法的重写或方法的覆盖（overriding）

要求：1、两个类，并具有继承关系的父子类；2、同名方法。
1、子类根据需求对父类继承的方法进行重新编写
2、重写时，可以用super.方法的方式来保留父类的方法
3、构造方法不能被重写

super

作用：子类访问父类成员
1、访问父类方法        【super.print();】
2、访问父类属性          【super.name】
3、访问父类构造方法     【super();或super(实参);】

注意：
1、使用super关键字，super代表父类对象
2、super只能出现在子类的方法和构造方法中
3、super调用构造方法时，只能是第一句
4、super不能访问父类的private成员

super的使用场景：

访问父类的成员

1、super只能出现在子类的方法和构造方法中
2、super调用构造方法时，只能在第一句
3、super不能访问父类的private成员

访问父类构造方法

super();
super(name);
使用super关键字，super代表父类对象。在子类构造方法中调用且必须是第一句

访问父类属性

super.name;

访问父类方法

super.print();

this和super的区别

this:
1、访问属性：访问本类属性，如果没有则从父类找
2、访问方法：访问本类方法，如果没有则从父类找
3、访问构造：调用本类构造方法，放在构造方法首行
super：
1、访问属性：访问父类中的属性
2、访问方法：访问父类中的方法
3、访问构造：调用父类构造，放在子类构造方法首行

abstract关键词

抽象方法：

1、抽象方法没有方法体
2、抽象方法必须在抽象类中
3、抽象方法必须在子类中被实现，除非子类是抽象类

抽象类：

没有办法创建自身对象，但是可以使用父类引用指向子类对象
1、抽象类不能被实例化，无意义
2、抽象方法所在的类必须是抽象类
3、抽象类中不一定要有抽象方法
4、一个类的抽象方法必须被子类实现，除非子类是抽象类
例如：public abstract void printA();

抽象类VS普通类

1、抽象类不能被实例化【但可以创建一个引用变量，器类型是一个抽象类，指向非抽象的子类实例】
2、普通类可以被实例化

抽象方法VS普通方法

有无方法体

抽象类与抽象方法的使用

1、抽象类中可以没有抽象方法，但是包含了抽象方法的类必须是被定义为抽象类
2、如果子类没有实现父类的所有抽象方法，子类必须被定义为抽象类
3、没有抽象构造方法，也没有抽象静态方法
4、抽象类中可以有非抽象的构造方法，创建子类的实例时可能调用

final修饰符

1、修饰的类，不能被继承
2、修饰的方法，不能被子类重写
3、修饰的变量将变成常量，只能在初始化时进行

继承条件下构造方法的调用规则

	1、子类构造方法没有通过super显式调用父类的有参构造方法，也没通过this显式调用自身其他构造方法【系统会默认调用父类的无参构造方法】（创建子类的对象时--->先进入父类的无参构造方法，但不执行--->再进入父类的父类中执行它的无参构造方法--->最够再进入父类中执行成员变量和无参构造）
	2、子类构造方法通过super显式调用父类的有参构造方法【执行父类相应构造方法，而不执行父类无参构造方法】
	3、子类构造方法通过this显式调用自身的其他构造方法，在响应构造方法中应用以上两条规则

继承条件下方法重写规则

	1、方法名相同
	2、参数列表相同
	3、返回值类型相同或者是其子类
	4、访问权限不能严于父类
	5、父类的静态方法不能被子类覆盖为非静态方法，父类的非静态方法不能被子类覆盖为静态方法
	6、子类可以定义为与父类同名的静态方法，以便在子类中隐藏父类的静态方法（注:静态方法中无法使用super）
	7、父类的私有方法不能被子类覆盖
	8、不能抛出比父类方法更多的异常

//爷爷类
public class GrandParent {
	private String name;
	
	public GrandParent(){
		System.out.println("GrandParent的无参构造方法！");
	}
	
	public GrandParent(String name){
		this.name = name;
		System.out.println("GrandParent的有参方法！");

	}
	
	
	
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	
	
	

	public void print() {
		System.out.println("GrandParent的普通方法！");
	}
	public static void staticPrint() {
		System.out.println("GrandParent的静态方法！");
	}
	
	
	
}
//父类
public class Parent extends GrandParent{
	private char gender;
	private int age;
	
	public Parent(){
		super();//调用父类的无参构造方法，不写会默认提供
		System.out.println("parent的无参构造方法！");
	}
	public Parent(String name,char gender){
		super(name);//调用父类的有参构造方法
		this.gender = gender;
		System.out.println("parent的两参方法！");

	}
	public Parent(String name,char gender,int age){
		this(name, gender);//调用本类中的两参构造方法
		this.age = age;
		System.out.println("parent的三参方法！");

	}
	public char getGender() {
		return gender;
	}
	public void setGender(char gender) {
		this.gender = gender;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	public void parentPrint() {
		System.out.println("parent中的普通方法！");
	}
	public static void parentStatic(){
		System.out.println("parent中的静态方法！");
	}
	private void privateFiled(){
		System.out.println("parent中的私有方法！");
	}
}
//子类
public class Son extends Parent {
	private String habit;
	
	public Son(){
		System.out.println("无参构造方法！");
	}
	public Son(String name,char gender,int age,String habit){
		super(name, gender, age);
		this.habit = habit;
		System.out.println("Son的有参方法！");
	}
	public void sonPrint(){
		System.out.println("子类的普通方法！");
	}
}
//测试类
public class ExtendsTest {
	public static void main(String[] args) {
		Son son1 = new Son();//创建Son无参对象
		System.out.println("******************");
		Son son2 = new Son("爷爷",'男',78,"打麻将");
		System.out.println("******************");
		son1.sonPrint();//调用Son的普通方法
		System.out.println("******************");
		son1.parentPrint();//调用parent的普通方法
		son1.parentStatic();//调用parent的静态方法
		Son.parentStatic();//类名直接调用parent的静态方法
		System.out.println("******************");
		son1.staticPrint();//调用GrandParent的静态方法
		Son.staticPrint();//用类名直接调用静态方法
		System.out.println("******************");
		
		
	}
}

重载与重写的区别

比较项	访问修饰符	位置	方法名	参数表	返回值
方法重写	不能严于父类	子类	相同	相同	相同或是其子类
方法重载	无关	同类	相同	不相同	无关

多态

什么是多态

同一个引用类型，使用不同的实力而执行不同的操作。
继承和方法重写时实现堕胎的基础
应用：父类引用指向子类对象

向上转型

通过父类引用变量调用的方法是子类覆盖或继承父类的方法，不是父类的方法【父类引用指向子类对象】，此时的父类引用变量无法调用子类特有的方法
语法：<父类型><应用变量名> = new <子类型>();

向下转型

将一个指向子类对象的父类引用赋给一个子类的引用，即：父类类型转换为子类类型。需强制类型转换

注意：
在向下转型的过程中，如果没有转换为真实子类类型，会出现类型转换异常ClassCastExcepetion【可以使用instanceof进行判断】

Java使用多态的两种主要方法

1、父类作为方法形参
2、父类作为方法返回值