封装
定义
将类的某些信息隐藏在类的内部,不允许外部程序直接访问,而是通过该类提供的方法来实现对隐藏信息的操作和访问
原则
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、父类作为方法返回值