------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流! -------
面向对象
1、什么叫面向对象?
面向对象(Object-Oriented,简称OO)就是一种常见的程序结构设计方法。
面向对象思想的基础是将相关的数据和方法放在一起,组合成一种新的复合数据类型,然后使用新创建的复合数据
类型作为项目的基础。
面向对象是一个很抽象的概念,它相对面向过程而言。
过程与对象都是一种解决问题的思想。
面向过程:强调的是功能行为,一种过程,先干啥,再干啥;
面向对象:将功能封装到对象里,强调的是具备某功能的对象;
按照面向对象的思想,可以把任何的东西看做对象!
面向对象的三大特征:
封装 :这样做比较安全
继承:这样做提高了代码的复用性
多态
2、类
类(class)是Java语言的最小编程单位,也是设计和实现Java程序的基础,本部分将深入介绍类的相关知识。
类的概念
类是一组事物共有特征和功能的描述。类是对于一组事物的总体描述,是按照面向对象技术进行设计时最小的单位,也是组成项目的最基本的模块。类的概念是抽象的,类似于建筑设计中的图纸,是对于现实需要代表的具体内容的抽象。类只包含框架结构,而不包含具体的数据。所以类代表的是总体,而不代表某个特定的个体。
3、构造方法
构造方法:用来构造类的实例(每一个类都默认有一个无参的构造方法,得使用new调用)
字段:类或对象所包含的数据,对类状态的一种描述;
方法:类或对象的特征或行为
作用:
给类中的字段进行初始化,可以用来创建对象。
特点:
方法名与类名相同
不用定义返回值类型
不需要写return语句
无参和带参的构造方法实例:
class Person{
private String name;
private int age;
private int sal;
public void show(){
System.out.println("个人情况:"+name+age+sal);
}
public Person(String name) {
super();
this.name = name;
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public Person(String name, int age, int sal) {
super();
this.name = name;
this.age = age;
this.sal = sal;
}
}
4.面向对象之封装
封装的两个含义:
1.把对象的状态和行为看成一个统一的整体,将二者存放在一个独立的模块中(类);
2."信息隐藏",把不需要让外界知道的信息隐藏起来,尽可能隐藏对象功能实现细节,字段;
封装机制在程序中的体现是:把描述对象的状态用字段表示,描述对象的行为用方法表示,把字段和方法定义在一个类中,并保证外界不能任意更改其内部的字段值,也不允许任意调动其内部的功能方法。
程序中的一种体现:通常将类中的成员变量私有化(private),通过对外提供方法(setXxx,getXxx),可对该变量(xxx)进行访问。
boolean 类型的变量没有getXX,只有isXX;
实例:
class Person1{
private String name;
private int age;
private int sal;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
5.权限修饰符:
rivate 类访问权限:本类内部可以访问,不能继承到子类;
default 什么都不写,包访问权限:本类内部可以访问,同包其他类也可以访问,同包可继承;
protected 子类访问权限:本类内部可以访问,不同包的子类也可以访问,同包其他类也可以访问,能继承到子类;
public 公共访问权限:任何地方都可以访问,能继承到子类;
6、面向对象之继承
首先有反映一般事物特性的类,然后在此基础上反映出特殊事物的类;
也就是说:继承是一种从一般到特殊的关系;
特点:
1、提高了代码的复用性。
2、让类与类之间产生关系,有了这个继承关系才有了多态的特性。
3、Java语言中只支持单继承(有别于C++语言)。
因为多继承容易带来安全隐患(父类多了, 功能相同的话,就会出现调用不确定性吗,覆写一个方法,到底覆写的谁的?)。
ps:接口可以实现多继承
4、Java支持多层继承,object是每个类的超类,实现树形结构
父类的私有成员子类不能继承到;父类的构造方法不能被继承;
Java只支持单继承,不支持多继承;//不然的话,比如show方法,继承了多个,不知道到底调用那一个。
一个类有且只有一个直接父类;
一个类没显示的继承其他的一个类的时候,默认的直接父类就是Object类;
Student 的直接父类是Person,Object类也是Student类的父类,但是是间接父类;
一旦一个类显示的继承了其他的一个类的时候,此时默认的直接父类Object就会被取消;
Java里一个类只能有一个直接父类;java.lang.Object是所有类的父类,Object要么是直接父类要么是间接父类。
子类对象实例化过程
在继承操作中,对于子类对象的实例化:
子类对象在实例化之前必须首先调用父类中的构造方法之后再调用自身的构造方法。
7、子类访问父类和方法覆写
子类不能直接访问父类的私有成员;
但是子类可以调用父类中的非私有方法来间接访问父类的私有成员。
Person类中有私有字段name,Student继承Person
new Sudent().name; ×
new Student().getName(); √
子类拓展父类(子类是父类的一种特殊情况)
主要是以父类为基础,然后添加属于自己的字段和方法。
方法覆写产生原因:
当父类中某个方法不适合于子类时,子类出现父类一模一样的方法.
判断必杀技:子类方法前加上@Override能编译通过,表明是方法的覆写。
调用被覆盖的父类方法:使用super.方法名(实参);
方法覆写时应遵循的原则(一同两小一大):
(一同):方法签名必须相同;
(两小):
子类方法的返回值类型比父类方法的返回值类型更小或相等
子类方法声明抛出的异常应比父类方法申明抛出的异常更小或相等;
(一大):子类方法的访问权限应比父类方法更大或相等;
子类需要覆写父类方法。
当父类的某个方法不适合于子类本身的特征行为时就当覆写父类中应当改变的方法。
8、super关键字和调用父类构造方法
表示父类对象的默认引用
如果子类要调用父类被覆盖的实例方法,可用super作为调用者调用父类被覆盖的实例方法。
使用super调用父类方法
使用super调用父类的构造方法
调用构造方法
本类中调用另一个重载构造方法用this(参数列表)
子类构造方法调用父类构造方法用super(参数列表)
子类调用父类的构造方法时:
super必须放在第一句
Java在执行子类的构造方法前会先调用父类无参的构造方法,其目的是为了对继承自父类的成员做初始化操作。
子类在创建对象的时候,默认调用父类的无参构造方法,要是子类构造方法中显示指定调用父类其他构造方法,就调用指定的父类构造方法,取消调用父类无参构造方法。
实例:
package reviewDemo;
class A{
String name;
A(){
System.out.println("父类默认隐式的构造方法!");
}
A(String name){
System.out.println("父类显式的构造方法!");
}
}
class B extends A{
B(){
super(null);
System.out.println("子类默认隐式的构造方法!");
}
}
public class Demo10 {
public static void main(String[] args) {
new B();
}
}
9、面向对象之多态
多态:指同一个实体同时具有多种形式
好比,你去面馆吃面,说我要吃面,那么;老板给我牛肉面,鸡蛋面等都可以,
这就是说"面"有多种形态,也就是说实体有多种形态;
编译时的类型由声明该变量时使用的类型决定,运行时的类型由实际赋给变量的对象决定。
如果编译时类型和运行时类型不同,就出现多态。
前提:Student extends Person:
Person p = new Person();
Student s = new Student();
Person p = new Student();//多态
引用关系:父类变量指向子类实例对象
实现多态的机制:
父类的引用变量可以指向子类的实例对象,而程序调用的方法在运行期才动态绑定,就是引用变量所指向的真正实例对象的方法,也就是内存里正在运行的那个对象的方法,而不是引用变量的类型中定义的方法。
多态的作用:
把不同的子类对象都当作父类来看,可以屏蔽不同子类对象之间的差异,写出通用的代码,做出通用的编程,以适应需求的不断变化。
只修改方法的实现,不必修改方法的声明
继承是多态产生的前提条件;
分类:
编译时多态:方法重载
运行时多态:方法覆写
package test;
class Dog{
void eat(){
System.out.println("一般的狗吃一般的狗粮!");
}
}
class HashDog extends Dog{
void eat(){
System.out.println("哈士奇吃哈士奇的狗粮!");
}
}
class ZangAoDog extends Dog{
void eat(){
System.out.println("藏獒吃藏獒的狗粮!");
}
}
//定义一个动物园喂的方法
class Zoo{
void feed(Dog d){
d.eat();
}
}
public class Demo11 {
public static void main(String[] args) {
Dog hd = new HashDog();
Dog zd = new ZangAoDog();
Zoo z = new Zoo();
z.feed(hd);
z.feed(zd);
}
}
10、代码块
代码块指的是使用"{}"括起来的一段代码,根据代码块存在的位置可以分为4种:
普通代码块;
构造代码块;
静态代码块;
同步代码块(线程同步的时候讲解)。
代码块里变量的作用域:
只在自己所在区域(前后的{})内有效;
普通代码块:
普通代码块就是直接定义在方法或语句中定义的代码块:
public void show(){
普通代码块
}
构造代码块:
直接写在类中的代码块:
优先于构造方法执行,每次实例化对象之前都会执行构造代码块。
public class Demo {
{
System.out.println("我是构造代码块");
}
public Demo(){
System.out.println("我是构造方法");
}
public static void main(String[] args) {
Demo d1 = new Demo();
Demo d2 = new Demo();
}
}
静态代码块
使用static 修饰的构造代码块:
优先于主方法执行,优先于构造代码块执行,不管有创建多少对象,静态代码块只执行一次,可用于给静态变量赋值;
package reviewDemo;
/**
* 测试各代码块的优先级
* 优先级顺序:静态代码块 > 构造代码块 > 普通代码块
* 备注:无论创建几个对象,静态代码块只执行一次!
*/
public class Demo13 {
Demo13(){
System.out.println("我是构造方法!");
}
{
System.out.println("我是构造代码块!");//实例化对象的时候才会去调用!
}
static{
System.out.println("我是静态代码块!");
}
public static void main(String[] args) {
new Demo13();
new Demo13();//再次创建对象,证明无论创建几次对象,静态代码块都只执行一次
System.out.println("我是普通代码块!");
}
}
11、final 关键字
① final可以修饰类,方法,变量。
② final修饰类不可以被继承,但是可以继承其他类。
③ final修饰的方法不可以被覆写,但可以覆写父类方法。
④ final修饰的变量称为常量,这些变量只能赋值一次。
⑤ 内部类在局部时,只可以访问被final修饰的局部变量。
⑥ final修饰的引用类型变量,表示该变量的引用不能变,而不是该变量的值不能变;
package reviewDemo;
final class Name{
}
class NewName extends Name{//ERROR,报错,因为Name有final修饰
}
public class Demo15 {
public static void main(String[] args) {
}
}
12、抽象类
当编写一个类时,我们往往会为该类定义一些方法,这些方法是用来描述该类的行为方式,那么这些方法都有具体的方法体。
但是有的时候,某个父类只是知道子类应该包含怎么样的方法,但是无法准确知道子类如何实现这些方法。
抽象方法的定义:通过abstract关键字来修饰的类称为抽象类;
我的总结:
抽象类用private修饰,里面可以有用private修饰的方法(没有方法体),强制子类进行覆写;
可以理解为:具有某些公共方法的一个总结类。
可以定义被abstract修饰的抽象方法
抽象方法只有返回类型和方法签名,没有方法体。
备注:
抽象类可以含有普通方法
抽象类不能创建实例对象(不能new)
需要子类覆盖掉所有的抽象方法后才可以创建子类对象,否则子类也必须作为抽象类
列举常见的几个抽象类:
流的四个基本父类
InputStream,OutputStream,Reader,Writer
我的总结:
抽象类是类的一种特殊情况:据有类的一切特点,但是不能实例化;一般的都得带有抽象方法。
抽象类不可以实例化,有时看到的近似实例化是多态机制的体现,并不是真正的实例化。
Eg:
Socket s = new Socket();
OutputStream os = s.getOutputStream();
左边是OutputStream类型变量的声明,右边是获取抽象类OutputStream的一个实例对象!
Socket s = new Socket();
OutputStream os = s.getOutputStream();
左边是OutputStream类型变量的声明,右边是获取抽象类OutputStream的一个实例对象!
package testDemo2;
abstract class Person{
}
class Student extends Person{
}
public class Demo2 {
public static void main(String[] args) {
Person p = new Student();//体现的是多态,父类声明实例化子类对象。而不是抽象类实例化
}
}
abstract方法
分析事物时,发现了共性内容,就出现向上抽取。会有这样一种特殊情况,就是功能声明相同,但功能主体不同。
那么这时也可以抽取,但只抽取方法声明,不抽取方法主体。那么此方法就是一个抽象方法。
abstract [非private访问修饰符] 返回值类型 方法名称(参数列表);
抽象方法要存放在抽象类中。
抽象方法也可以存在于接口中
package reviewDemo;
abstract class Person3{
abstract void show();
abstract void inof();
void turn(){
}
}
class NewP extends Person3{
@Override
void show() {
}
@Override
void inof() {
}
//不覆写的话会报错
}
public class Demo15 {
public static void main(String[] args) {
//new Person3();报错!因为抽象类不可以实例化
}
}