JavaSE

面向对象
- 类和对象
- - 定义一个标准类
  - 创建并使用对象
- 对象的内存图
- 匿名对象
- - 匿名对象的概述
  - 使用匿名对象
继承
- 继承概述
- - 为什么要有继承
  - 继承的含义
  - 继承的好处
- 继承的格式
- - 格式
  - 示例
- 继承后成员访问规则
- - 继承后构造放法的访问规则
  - 继承后私有成员的访问规则
  - 继承后非私有成员的访问规则
- 方法重写
- - 方法重写的概念
  - 重写的注意事项
- this和super关键字
- - this和super关键字的介绍
  - this关键字的三种用法
  - super关键字的三种用法
  - super的注意事项
  - - super的注意事项一
    - super的注意事项二
- 继承体系对象的内存图
- 继承的特点
抽象类
- 抽象类的概述和定义
- - 抽象类的概述
  - 抽象类的定义
  - 抽象类中的成员
- 抽象方法的概述和定义
- - 抽象方法的概述
  - 抽象方法的定义
  - 注意事项
- 抽象类的特点
- 模版设计模式
- - 设计模式概述
  - 模版设计模式概述
  - 模版模式的实现步骤
  - 示例

面向对象

类和对象

定义一个标准类

定义类的格式：

修饰符 class 类名{// 成员变量(private修饰)// 构造方法(空参,满参)// set\get方法// 成员方法(行为)
}

示例

public class Student {// 成员变量private String name;// 构造方法public Student() {}public Student(String name) {this.name = name;}// 成员方法public String getName() {return name;}public void setName(String name) {this.name = name;}public void study(){System.out.println("study...");}public void eat(String foodName){System.out.println("学生在吃"+foodName+"...");}
}

创建并使用对象

创建对象的格式：

通过调用构造方法创对象:类名 对象名 = new 类名(实参);

使用对象：

对象访问成员变量

对象名.成员变量名

对象访问成员方法

对象名.成员方法名(实参);

示例

public static void main(String[] args) throws Exception{// 创建Student类的对象Student stu1 = new Student();Student stu2 = new Student("小明",16);// 使用Student类的对象// 访问成员变量: 通过set和get方法进行访问stu1.setName("小白");stu1.setAge(17);System.out.println("stu1的姓名:"+stu1.getName()+",年龄是:"+stu1.getAge());// 访问成员方法stu1.study();}

对象的内存图

只要是new对象就会在堆区开辟一块独立的空间
只要调用方法，方法就会被加载进栈
只要方法执行完毕，方法就会被弹栈

匿名对象

匿名对象的概述

就是指“没有名字”的对象

有名字的对象：Student stu = new Student();stu.show();stu.study();
匿名对象：new Student();

使用匿名对象

特点：匿名对象只能使用一次

public class Demo {public static void main(String[] args) {//有名字的对象Student stu3 = new Student();fun(stu3);//匿名对象--写法上比较简单fun(new Student());}public static void fun(Student student) {}
}

继承

继承概述

为什么要有继承

继承的含义

在java中指的是“一个类”可以“继承自”“另一个类”。 "被继承的类"叫做: 父类/超类/基类，"继承其他类的类"叫做:子类。继承后，“子类”中就“拥有”了“父类”中所有的成员(成员变量、成员方法)。 “子类就不需要再定义了”。

继承的好处

提高代码的复用性（减少代码冗余，相同代码重复利用）。
使类与类之间产生了关系。

继承的格式

格式

通过extends关键字，可以声明一个子类继承另外一个父类，定义格式如下：

class 父类 {...
}class 子类 extends 父类 {...
}

需要注意：Java是单继承的，一个类只能继承一个直接父类，并且满足is-a的关系,例如:Dog is a Animal, Student is a Person

示例

人类:
public class Person {// 成员变量String name;int age;// 功能方法public void eat(){System.out.println("吃东西...");}public void sleep(){System.out.println("睡觉...");}
}
老师类: extends 人类
public class Teacher extends Person {}
测试:
public class Demo {public static void main(String[] args) {Teacher t = new Teacher();System.out.println(t.name);System.out.println(t.age);t.eat();t.sleep();}
}

继承后成员访问规则

继承后构造放法的访问规则

构造方法不能被继承

public class Fu{public Fu(){}public Fu(String name,int age){}
}
public class Zi extends Fu{}
public class Demo {public static void main(String[] args) {Zi z = new Zi("小明", 18);//编译错误，Zi类没有全参构造}
}

继承后私有成员的访问规则

父类的“私有成员”可以被子类继承，但子类不能被直接访问

public class Fu{private int num = 100;//私有成员，只能在父类内部使用。private void method(){System.out.println("私有成员方法");}
}
public class Zi extends Fu{}
public class Demo {public static void main(String[] args) {Zi z = new Zi();System.out.println(z.num);// 编译错误z.method();// 编译错误}
}

继承后非私有成员的访问规则

当通过“子类”访问非私有成员时，先在子类中找，如果找到就使用子类的，找不到就继续去“父类”中找。

public class Fu{int money = 100;public void method(){System.out.println("Fu 类中的成员方法method");}
}
public class Zi extends Fu{int money = 1;public void method(){System.out.println("Zi 类中的成员方法method");}
}
public class Demo{public static void main(String[] args){Zi z = new Zi();System.out.println(z.money);//1z.method();// Zi 类中的成员方法method}
}

方法重写

方法重写的概念

方法重写 ：子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写。声明不变，重新实现。

public class Fu{public void method(){System.out.println("打游戏...");}
}
public class Zi extends Fu{@Overridepublic void method(){//方法重写System.out.println("看电影...");}
}
//测试类
public class Demo {public static void main(String[] args) {Zi zi = new Zi();zi.method();// 看电影...}
}

重写的注意事项

方法重写是发生在子父类之间的关系
子类方法重写父类方法，返回值类型、方法名和参数列表都要一模一样
子类方法重写父类方法，必须要保证权限大于等于父类权限。访问权限从大到小：public < protected < (默认) < private
使用@Override注解，检验是否重写成功，重写注解校验。建议重写方法都加上这个注解，一方面可以提高代码的可读性，一方面可以防止重写出错

this和super关键字

this和super关键字的介绍

this：存储的“当前对象”的引用；this可以访问：本类的成员属性、成员方法、构造方法
super：存储的“父类对象”的引用；super可以访问：父类的成员属性、成员方法、构造方法

this关键字的三种用法

this访问本类成员变量：this.成员变量

public class Student{String name = "小明";public void show(){String name = "小红";System.out.println("name = " + name);// 小红System.out.println("name = " + this.name);// 小明}
}

this访问本类成员方法：this.成员方法名();

public class Student{public void show(){System.out.println("show方法...");this.eat();}public void eat(){System.out.println("eat方法...");}
}

this访问本类构造方法：this()可以在本类的一个构造方法中，调用另一个构造方法

public class Student{public Student(){System.out.println("空参构造方法...");}public Student(String name) {this();//当使用this()调用另一个构造方法时，此代码必须是此构造方法的第一句有效代码。System.out.println("有参构造方法...");}
}
public class Demo {public static void main(String[] args) {Student stu2 = new Student();}
}

super关键字的三种用法

super访问父类的成员变量：super.父类成员变量名

public class Fu{int money = 100;
}
public class Zi extends Fu{int money = 10;public void show(){int monet = 1;System.out.println(“money : “ + money);//1System.out.println(“this.money : “ + this.money);//10System.out.println(“super.money：” + super.money);//100  直接去父类中找}
}

super访问父类的成员方法：super.成员方法名();

public class Fu{public void show(){System.out.println("父类的show方法...");}
}
public class Zi extends Fu{public void show(){super.show();System.out.println("子类的show方法...");}
}
public class Demo {public static void main(String[] args) {Zi zi = new Zi();zi.show();}
}

super访问父类的构造方法：super()

public class Fu{public Fu(){System.out.println("Fu 类的空参构造方法..");}public Fu(String name, int age) {System.out.println("Fu 类的有参构造方法..");}
}
public class Zi extends Fu{public Zi(){super();// 调用父类的空参构造方法System.out.println("Zi 类的空参构造方法..");}public Zi(String name,int age){super(name,age);// 调用父类的有参构造方法System.out.println("Zi 类的有参构造方法..");}
}
public class Demo {public static void main(String[] args) {Zi zi = new Zi();System.out.println("----------------------");Zi z2 = new Zi("小明", 18);}
}

super的注意事项

super的注意事项一

super访问成员变量和成员方法：优先去父类中找，如果有就直接使用,如果没有就去爷爷类中找,如果有,就用,依次类推…

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

super的注意事项二

子类的构造方法默认会调用父类的空参构造方法，如果父类中的没有空参构造方法，只定义了有参构造方法，会编译报错

class Fu {public Fu(int a){}
}class Zi extends Fu{// 编译报错}

继承体系对象的内存图

继承体系内存图原理—父类空间优先于子类对象产生
在每次创建子类对象时，先初始化父类空间，再创建其子类对象本身。目的在于子类对象中包含了其对应的父类空间，便可以包含其父类的成员，如果父类成员非private修饰，则子类可以随意使用父类成员。代码体现在子类的构造方法调用时，一定先调用父类的构造方法。
示例

public class Fu {int num = 10;int numFu = 100;public void method(){System.out.println("父类中的method方法");}
}
public class Zi extends Fu {int num = 20;public void show(){int num = 30;System.out.println("访问局部变量num:"+num);System.out.println("访问本类成员变量num:"+this.num);System.out.println("访问父类成员变量num:"+super.num);}@Overridepublic void method() {super.method();System.out.println("子类中的method方法");}
}
public class Demo {public static void main(String[] args) {// 创建一个子类对象Zi zi = new Zi();// 使用子类对象调用show方法zi.show();// 使用子类对象调用method方法zi.method();}
}

根据示例绘制内存图

继承的特点

Java只支持单继承，不支持多继承。

  // 一个类只能有一个父类，不可以有多个父类。
class A {}
class B {}
class C1 extends A {// ok}
class C2 extends A, B {// error}

一个类可以有多个子类。

  // A可以有多个子类
class A {}
class C1 extends A {}
class C2 extends  A {}

可以多层继承。

class A {// 爷爷}
class C1 extends A {// 父亲}
class D extends C1 {// 儿子}

tips：顶层父类是Object类。所有的类默认继承Object，作为父类。class A { }：默认继承Object类，class B extends A { }：B的父类就是A，但是A的父类是Object类。

抽象类

抽象类的概述和定义

抽象类的概述

概述：使用abstract关键字修饰的类就是抽象类
特点：这种类不能被创建对象，它就是用来做父类的，被子类继承的

抽象类的定义

格式：

修饰符 abstract class 类名{}

示例

public abstract class Person{}

抽象类中的成员

成员变量
成员方法
构造方法
抽象方法

抽象方法的概述和定义

抽象方法的概述

没有方法体，使用abstract修饰的方法就是抽象方法

抽象方法的定义

修饰符 abstract 返回值类型 方法名(形参列表);
例如:public abstract void work();

注意事项

如果子类是一个抽象类,父类是抽象类,那么子类可以不用重写父类中的抽象方法。
如果子类是一个普通类,父类是抽象类,那么子类必须重写父类中所有的抽象方法

抽象类的特点

抽象类不能被创建对象，就是用来做“父类”，被子类继承的。
抽象类不能被创建对象，但可以有“构造方法”——为成员属性初始化。
抽象类中可以没有抽象方法,但抽象方法必须定义在抽象类中。
子类继承抽象类后,必须重写抽象类中所有的抽象方法,否则子类必须也是一个抽象类。

模版设计模式

设计模式概述

设计模式就是解决一些问题时的固定思路，也就是代码设计思路经验的总结。

模版设计模式概述

针对某些情况,在父类中指定一个模板,然后根据具体情况,在子类中灵活的具体实现该模板
抽象类体现的就是模板思想，模板是将通用的东西在抽象类中具体的实现，而模板中不能决定的东西定义成抽象方法，让使用模板（继承抽象类的类）的类去重写抽象方法实现需求
抽象类: - - - 看成是模板
模板是将通用的东西在抽象类中具体的实现 : 非抽象方法定义一些通用的功能
模板中不能决定的东西定义成抽象方法

模版模式的实现步骤

定义父类(抽象类)作为模板
在父类中定义"模板方法" - - - 实现方法(模板)+抽象方法(填充模板)
子类继承父类,重写抽象方法(填充父类的模板)
测试类：创建子类对象，通过子类调用父类的“实现的方法”+ “子类重写后的方法”

示例

假如现在需要定义新司机和老司机类，新司机和老司机都有开车功能，开车的步骤都一样，只是驾驶时的姿势有点不同，新司机:开门,点火,双手紧握方向盘,刹车,熄火，老司机:开门,点火,右手握方向盘左手抽烟,刹车,熄火。那么这个时候我们就可以将固定流程写到父类中，不同的地方就定义成抽象方法，让不同的子类去重写

抽象类代码如下

// 司机开车的模板类
public abstract class Driver {public void go() {System.out.println("开门");System.out.println("点火");// 开车姿势不确定?定义为抽象方法ziShi();System.out.println("刹车");System.out.println("熄火");}public abstract void ziShi();
}

现在定义两个使用模版的司机

public class NewDriver extends Driver {@Overridepublic void ziShi() {System.out.println("新司机双手紧握方向盘");}
}public class OldDriver extends Driver {@Overridepublic void ziShi() {System.out.println("老司机右手握方向盘左手抽烟...");}
}

编写测试类

public class Demo02 {public static void main(String[] args) {NewDriver nd = new NewDriver();nd.go();OldDriver od = new OldDriver();od.go();}
}

可以看出，模板模式的优势是，模板已经定义了通用架构，使用者只需要关心自己需要实现的功能即可！非常的强大！

JavaSE（面向对象、继承、抽象类）相关推荐

JavaSE——面向对象高级（继承、final关键字、抽象类与接口、多态、Object类、内部类、包装类、可变参数）
第3节面向对象高级一.继承 1.1 概述和使用继承是java面向对象编程技术的一块基石,因为它允许创建分等级层次的类.继承就是子类继承父类的特征和行为,使得子类对象(实例)具有父类的实例域和方法 ...
JavaSE面向对象：继承、多态、Super、Object类、重写、static、final、静态成员、懒汉式、饿汉式、单例设计模式、初始化块、抽象类、抽象方法、接口
感谢尚硅谷免费提供的视频继承 ** 理解 ** 生活中的继承:子女继承了父母的财产或相貌或才华 java中的继承:一个类不用自己定义属性或方法,就已经具备了另一个类的属性和方法把这种现象称为jav ...
12.面向对象(继承/super/接口/抽象类)
面向对象继承与派生继承继承顺序继承原理子类调用父类的方法(super) 组合接口接口的概念: 接口的概念解释和使用: python中的接口: 抽象类面向对象继承与派生继承什么是继 ...
13 面向对象-继承与抽象类
第01天 java面向对象今日内容介绍  继承  抽象类第1章继承 1.1 继承的概述在现实生活中,继承一般指的是子女继承父辈的财产.在程序中,继承描述的是事物之间的所属关系,通过继承可以 ...
【小白学java】java的面向对象设计：封装+继承+抽象类+接口（day06）
课程链接:共六天第一天:开发环境:初识java,搭建环境第二天:语言基础:关键字.变量.常量.运算符第三天:数据结构:基本类型.包装类型.引用类型(数组和对象) 第四天:流程控制:分支判断.循环 ...
面向对象————继承、封装、多态、抽象类
一.继承 1.定义:是面向对象最显著的一个特性.继承是从已有的类中派生出新的类,新的类能吸收已有类的数据属性和行为,并能扩展新的能力. Java继承是使用已存在的类的定义作为基础建立新类的技术,新类的 ...
笔记整理3----Java语言高级（三）11 综合练习+12 面向对象-static变量与代码块+13 面向对象-继承与抽象类+14 面向对象-接口与多态+15 面向对象-包修饰符
11 综合练习+12 面向对象-static变量与代码块+13 面向对象-继承与抽象类+14 面向对象-接口与多态+15 面向对象-包&修饰符第11天综合练习今日内容介绍 综合练习 ...
PHP面向对象之旅：抽象类继承抽象类(转)
可以理解为对抽象类的扩展抽象类继承另外一个抽象类时,不用重写其中的抽象方法.抽象类中,不能重写抽象父类的抽象方法.这样的用法,可以理解为对抽象类的扩展. 下面的例子,演示了一个抽象类继承自另外一个抽 ...
《JAVASE系列》抽象类与接口
<JAVASE系列>抽象类与接口文章目录 <JAVASE系列>抽象类与接口前言 1.抽象类 1.1抽象类是什么? 1.2 抽象的语法与细节 1.3抽象类的意义与作用 2.接 ...
Python之面向对象继承和派生
Python之面向对象继承和派生什么是继承: 继承是一种创建新的类的方法.在Python中,新建的类可以继承自一个或多个父类.原始类称为基类或超类. 新建的类称为派生类或子类. Python中类的继 ...

JavaSE（面向对象、继承、抽象类）