文章目录
前言
关键字static以及面向对象的三大特性:封装、继承和多态。一、static
1.static变量
---1.使用static修饰的成员变量,为类变量,属于类。
---2.在类加载时就被初始化
---3.生命周期和类一致
---4.可以通过类名.变量名调用
2.static方法
---1.在static方法中,不可以直接访问非static的变量和方法
---2.可以通过类名.方法名进行调用
---3.不可以访问this
3.static代码块
局部代码块 | 成员代码块 | static代码块 | |
位置 | 方法中 | 类中 | 类中 |
数量 | 多个 | 多个 | 多个 |
执行顺序 | 依次执行 | 依次执行 | 依次执行 |
执行时间 | - | 每次创建对象时 | 第一次类加载时,只执行一次 |
代码示例:
public class Test {
public static void main(String[] args) {
Person p =new Person();
p.showName();
Person p2 =new Person();
}
}
class Person{
// 成员变量
static String firstName;
String lastName ;
// 成员方法
public void showName(){
System.out.println(firstName+lastName);
}
public Person (){
System.out.println("无参构造方法");
}
public Person(String lastName){
System.out.println("有参构造方法");
this.lastName=lastName;
}
// 代码块 代码块不能被调用,代码块是在指定的环节自动执行的
{
System.out.println("普通代码块");
lastName="小明";
}
static{
System.out.println("静态代码块");
firstName="李";
}
}
4.static优缺点
---优点:不需要实例化,静态变量的值可以直接重新赋值,静态方法可以通过类名.方法名调用
---缺点:初始化加载到内存,如果后续没被引用,很占用内存空间
二、封装性
1.定义
---封装就是把对象的属性和操作结合为一个独立的整体,并尽可能隐藏对象的内部的实现细节,仅仅对外公开使用的接口/方法
2.特点
---1.提高代码复用性
---2.提高代码安全性
---3.高内聚,低耦合:封装细节便于维护,简化外部调用。
3.封装示例
public class Student {
//1属性私有化
//使用private访问修饰符修饰成员变量
//2提供公有的外界访问的get、set方法
//boolean变量的get方法是is开头!
private String name;
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
public void showInfo(){
System.out.println("姓名:"+name);
}
}
三、继承性
1.定义
---extends:字面意思是扩展 ,子类是父类的扩展,实现代码的重用。
2.要点
---1.Java中只有单继承
---2.如果一个类中没有调用extends,则它的父类是java.lang.Object
---3.子类继承父类,可以得到父类的全部属性和方法,但是不一定可以访问
3.继承示例
public class Test {
public static void main(String[] args) {
Student student = new Student();
student.setName("小明");
student.rest();
student.study();
}
}
//父类
class Person{
private String name;
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
public void rest(){
System.out.println(name+"睡觉");
}
public Person(){}
public Person(String name) {
this.name = name;
}
}
//子类
class Student extends Person{
public Student() {
}
public Student(String name) {
super(name);
}
public void study(){
System.out.println("学习");
}
}
3.方法重写
---1.发生在子类和父类中间
---2.方法名相同、修饰符大于等于父类方法、返回值等于、参数相同、抛出的异常要小于等于父类。
---3.可以添加@override注解,检测是否重写
---4.父类中final修饰的方法不能被重写
//子类,延用上面的例子,对子类做出一下修改
class Student extends Person{
public Student() {
}
public Student(String name) {
super(name);
}
//重写父类中的rest()方法
public void rest(){
System.out.println("子类重写睡觉");
}
public void study(){
System.out.println("学习");
}
}
4.权限修饰符
---private:表示私有,只有自己类可以访问
---default(friendly):没有修饰符,只有同包的类能访问
---protected:可以被同包中的类以及其他包中的子类访问
---public:公开的,该项目所有包中的所有类都可以访问
修饰符 | 同一个类 | 同一个包(同包可继承) | 子类 | 所有包所有类 |
private | √ | - | - | - |
默认/default | √ | √ | - | - |
protected | √ | √ | √ | - |
public | √ | √ | √ | √ |
四、多态性
1.定义
---多态指的是同一个方法调用,由于对象的不同可能会有不同的行为
2.要点
---1.多态是方法的多态,不是属性的多态,与属性无关
---2.三个必要条件:a.继承关系 b.方法重写 c.父类引用指向子类对象
---开闭原则OCP:对扩展开放,对修改关闭
多态示例:
class Action{
public void eat(){
System.out.println("吃米饭");
}
}
class P1 extends Action{
public void eat(){
System.out.println("吃面条");
}
public void drink(){
System.out.println("喝汽水");
}
}
class P2 extends Action{
public void eat() {
System.out.println("吃汉堡");
}
}
3.向上转型
---定义:将子类对象赋给父类引用;
---Fu fu = new Zi();
4.向下转型
---定义:将父类的引用变量转换为子类类型
---需要强制转换:Zi zi = (Zi)fu;
---需要用 fu instanceof Zi 判断在继承树上是否有上下级关系(避免ClassCastException)
5.抽象方法和抽象类
a.概念
---抽象方法:使用abstract修饰的方法,没有方法体,只有声明,是一种“规范”
---抽象类:使用abstract修饰的类,通过abstract方法定义规范,子类必须具体实现。
b.要点
---1.有抽象方法的类只能定义成抽象类
---2.抽象类不能实例化,不能new
---3.抽象类必须有构造方法,创建子类对象时候用
---4.子类必须实现父类的抽象方法
//定义抽象类、抽象方法
abstract class Play {
public abstract void games();
}
//子类继承实现抽象方法
class Student extends Play {
public void games() {
System.out.println("玩游戏");
}
}