java基础—面向对象
一、面向对象
- 面向对象的概念:面向对象是相对面向过程而言,面向对象和面向过程都是一种思想。(面向对象是一种以执行功能的对象为主体的思想)
- 面向对象的特点:是一种符合人们思考习惯的思想,可以将复杂的事情简单化,将程序员从执行者转换成了指挥者。
- 面向对象的特征:封装(encapsulation),继承(inheritance),多态(polymorphism)。
1.1 封装
- 概念:是指隐藏对象的属性和实现细节,仅对外提供公共访问方式。
- 好处:
- 将变化隔离。
- 便于使用。
- 提高重用性。
- 提高安全性。
- 封装原则:
- 将不要对外提供的内容都隐藏起来。
- 把属性都隐藏,提供公共方法对其访问。如:getXXX,setXXX。
1.2 继承
- 描述的描述:
- 通过extends关键字让类与类之间产生继承关系。
- 多个类有相同的属性和行为时,将这些内容抽取到单独一个类中,那么多个类无需定义这些属性和行为,只要继承那个类即可。多个类可以称为子类,单独这个类称为父类或者超类。
- 子类无法继承父类中的私有类容。
- 继承的优点:
- 继承的出现提高了代码的复用性。
- 继承的出现让类与类之间产生了关系,提供了多态的前提。
- 继承的的特点:
- java只支持单继承,不支持多继承。
- 一个类只有一个父类,不可以有多个父类。
- java支持多层继承(继承体系)
- 函数覆盖:
- 当子父类中出现成员函数一模一样的情况,会运行子类的函数。这种现象称为覆盖操作,这是函数在子父类中的特性。
- 在子类覆盖方法中,继续使用被覆盖的方法可以通过super.函数名获得。
- 示例:
- 代码:
class Person
{
String name;
int age;
void study()
{
System.out.println("Person……"+age);
}
}
//Student继承了Person类
class Student extends Person
{
//继承了父类中的成员变量
//复写了Person类中study方法
void study()
{
System.out.println("student study……"+age);
}
}
class ExtendDemo
{
public static void main(String args[])
{
Student s=new Student();
s.name="张三";
s.age=20;
s.study();
}
}
- 输出结果:
1.3 多态
- 定义:某一类事物的多种存在形式。
- 体现:父类或者接口的引用指向或者接收自己的子类对象。
- 作用:多态的存在提高了程序的扩展性和后期可维护性。
- 前提:
- 需要存在继承或者实现关系。
- 需要有覆盖操作。
- 好处:提高了代码的扩展性,前期定义的代码可以使用后期的内容。
- 多态时,成员的特点:
- 成员变量
- 编译时:参考引用型变量所属的类中是否有调用的成员变量。有,编译通过,没有,编译失败。
- 运行时:参考引用型变量所属的类中是否有调用的成员变量,并运行该所属类中的成员变量。
- 简单说:编译和运行都参考等号的左边。
- 成员函数(非静态)
- 编译时:参考引用型变量所属的类中是否有调用的函数。有,编译通过,没有,编译失败。
- 运行时:参考的对象所属的类中是否有调用的函数。
- 简单说,编译看左边,运行看右边。
- 静态函数
- 编译时:参考的是对象所属的类中是否有调用的函数。
- 运行时:参考的是对象所属的类中是否有调用的函数。
- 简单说:编译和运行看左边。
- 成员变量
- 示例:
- 代码:
class Fu
{
int age=40;
public static void see()
{
System.out.println("张父");
}
}
//继承Fu类
class Zi extends Fu
{
int age=4;
public static void see()
{
System.out.println("张三");
}
}
class Demo
{
public static void main(String[] args)
{
//多态,父类引用接收子类对象
Fu x=new Zi();
//静态函数编译和运行时都看父类引用
x.see();
//成员变量编译和运行时都看父类引用
System.out.println(x.age);
}
}
- 输出结果
二、类与对象
- 类的定义:类是具体事物的抽象描述,概念上的定义。
- 对象的定义:对象即是该类事物实实在在存在的个体。
- 类与对象的关系:类是对象的抽象,对象是类的实例。
2.1 内部类的介绍
- 定义:将一个类定义在另一个类的里面,里面那个类就称为内部类(内置类,嵌套类)。
- 访问的特点:
- 内部类可以直接访问外部类中的成员,包含私有成员。
- 而外部类要访问内部类中的成员必须要建立内部类的对象。
- 内部类的位置:内部类定义在成员位置上,可以被private、static修饰。被static修饰的内部类只能访问外部类中的静态成员。
2.2 匿名内部类
- 定义:就是内部类的简化写法。
- 前提:内部类可以继承或实现一个外部类或接口。
- 格式:
new 外部类名或者接口名(){覆盖类或者接口中的代码,(也可以自定义内容。)}
- 简单理解:就是建立一个带内容的外部类或者接口的子类匿名对象。
2.3 接口
接口的定义:当一个抽象类中的方法都是抽象的时候,这时可以将该抽象类用另一种形式定义和表示,就是接口。
格式:
interface{}
接口中的成员修饰符是固定的:
- 成员常量:public static final
- 成员函数:public abstract
- 接口中的成员都是公共的权限。
特点:
- 接口是对外暴露的规则。
- 接口是程序的功能扩展。
- 一个类可以实现多个接口。
综合案例
- 代码:
//实现功能的扩展。
interface USB
{
//暴露的原则
public abstract void open();
public abstract void close();
}
//实现的原则
//降低了耦合性
class Upan implements USB
{
public void open()
{
System.out.println("Upan open");
}
public void close()
{
System.out.println("Upan close");
}
}
class UsbMouse implements USB
{
public void open()
{
System.out.println("UsbMouse open");
}
public void close()
{
System.out.println("UsbMouse close");
}
}
class PC
{
public static void main(String[] args)
{
//功能扩展了
UseUSB(new UsbMouse());
}
//使用原则
public static void UseUSB(USB u)//接口类的引用,用于接收(指向)接口的子类对象
{
if(u!=null);
{
u.open();
u.close();
}
}
}
- 输出结果:
2.4 对象
对象的产生:创建对象的根本途径是构造器(特殊的方法),通过new关键字来调用某个类的构造器即可创建这个类的实例。
匿名对象:
- 对象的简化形式(一个没有名字的对象, 创建了一个对象出来,没有赋给一个变量)
- 使用情形:
- 当对对象方法仅一次调用时。
- 作为实际参数进行传递时。
2.5 成员变量和静态变量的区别
1. 两个变量的生命周期不同:
- 成员变量随着对象的创建而存在,随着对象被回收而释放。
- 静态变量随着类的加载而存在,随着类的消失而消失。
2. 调用方式不同:
- 成员变量只能被对象调用。
- 静态变量既可以被对象调用也可以被类调用。
3. 别名不停:
- 成员变量也称为实例变量。
- 静态变量也称为类变量。
4. 数据储存位置不同:
- 成员变量存储在堆内存的对象中,所以也叫对象的特有数据。
- 静态变量数据存储在方法区(共享数据区)的静态区,所以叫数据的共享数据。
三、构造函数和构造代码块
3.1 构造函数
特点:
- 函数名与类名相同。
- 不用定义返回值类型。
- 没有具体的返回值。
作用:给对象进行初始化。
3.2 构造代码块
- 作用:可以给所有对象进行初始化。
四、单例设计模式
- 概念:单例设计模式就是保证一个类在内存中的对象唯一性。
- 实现步骤:
- 私有化该类构造函数。
- 通过new在本类中创建一个本类对象。
- 定义一个公有的方法,将创建的对象返回。
4.1 饿汉式
- 代码:
class Single
{
//对构造函数进行私有化,无法在其它类中创建对象
private Single(){}
//在本类中创建一个本类对象
private static Single s=new Single();
//提供一个方法,将创建的对象返回
public static Single getInstance()
{
return s;
}
}
class SingleDemo
{
public static void main(String[] args)
{
Single s1=Single.getInstance();
Single s2=Single.getInstance();
//s1,s2为同一个对象
System.out.println(s1==s2);
}
}
- 输出结果:
4.2 懒汉式
- 代码:
class Single1
{
private Single1(){}
//延迟加载形式,只有调用了getInstance方法时,才会创建对象。
private static Single1 s =null;
public static Single1 getInstance()
{
if(s==null)
s=new Single1();
return s;
}
}
class SingleDemo1
{
public static void main(String args[])
{
Single1 s1=Single1.getInstance();
Single1 s2=Single1.getInstance();
//s1,s2为同一个对象
System.out.println(s1==s2);
}
}
- 输出结果: