Java面向对象

发表于 更新于 阅读次数： 本文字数： 5k 阅读时长 ≈ 9 分钟

Java 对象和类

  • 类和对象的关系
    类:类是对现实生活中一类具有共同属性和行为的事物的抽象
    对象:是能够看得到摸的着的真实存在的实体

  • 类的定义
    类的重要性:是Java程序的基本组成单位
    类是什么:是对现实生活中一类具有共同属性和行为的事物的抽象，确定对象将会拥有的属性和行为

    类的特点：类是对象的数据类型，是具有相同属性和行为的事物的抽象

    类的组成:属性和行为
    属性:在类中通过成员变量来体现(类中方法外的变量)
    行为:在类中通过成员方法来体现(和前面的方法相比去掉static关键字即可)

  • 对象的定义

    看看周围真实的世界，会发现身边有很多对象，车，手机，人等等。所有这些对象都有自己的属性和行为。

​ 拿一个手机来举例，它的属性有：品牌、价格，行为有：打电话、发短信。

​ 软件对象也有属性和行为。行为通过方法体现。

​ 在软件开发中，方法操作对象内部状态的改变，对象的相互调用也是通过方法来完成。

Java 中的类

类可以看成是创建 Java 对象的模板。

pubIic class Phone {

​ //成员变量

​ String brand;

​ int price;

​ //成员方法

​ public void call(){

​ System.out.printIn(“打电话”);}
​ public void sendMessage(){

​ System.out,pnintIn(“发短信”);}

}

成员变量和局部变量的区别

区别 成员变量 局部变量
类中位置不同 类中方法外 方法内或者方法声明上
内存中位置不同 堆内存 栈内存
生命周期不同 随着对象的存在而存在，随看对象的消失而消失 随着方法的调用而存在，随着方法的调用完毕而消失
初始化值不同 有默认的初始化值 没有默认的初始化值，必须先定义，赋值，才能使用
  • 局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
  • 成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
  • 类变量：类变量也声明在类中，方法体之外，但必须声明为 static 类型。

创建对象

格式:类名对象名 = new 类名0;
范例: Phone p = new Phone0;

使用对象

  1. 使用成员变量
    格式:对象名.变量名
    范例:p.brand
  2. 使用成员方法
    格式:对象名.方法名()
    范例: p.call()

封装

一、private关键字

  • 是一个权限修饰符
  • 可以修饰成员 (成员变量和成员方法)
  • 作用是保护成员不被别的类使用，被private修饰的成员只在本类中才能访问

针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作

  • 提供“get变量名()”方法，用于获取成员变量的值，方法用public修饰
  • 提供“set变量名(参数)”方法，用于设置成员变量的值，方法用public修饰

二、this关键字

  1. this修饰的变量用于指代成员变量
    方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量
    方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量

  2. 什么时候使用this呢? 解决局部变量隐藏成员变量

  3. this 代表所在类的对象引用
    记住:方法被哪个对象调用，this就代表哪个对象

三、封装

  1. 封装概述
    是面向对象三大特征之一 (封装，继承，多态)
    是面向对象编程语言对客观世界的横拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作
  2. 封装规则
    将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对的冠信息的操作和访问成员变量private，提供对应的getXxx()/setXxx()方法
  3. 好处
    通过方法来控制成员变量的操作，提高了代码的安全性
    把代码用方法进行封装，提高了代码的复用性

四、构造方法

在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法。

下面是一个构造方法示例：

public class Student{

​ public Student(){ }

​ public Student(String name){

​ // 这个构造器仅有一个参数：name } }

注意事项：

  1. 构造方法的创建

    如果没有定义构造方法，系统将给出一个认的无参数构造方法
    如果定义了构造方法，系统将不再提供默认的构造方法

  2. 构造方法的重载
    如果自定义了带参构造方法，还要使用无参数构造方法，就必须再写一个无参数构造方法

  3. 推荐的使用方式
    无论是否使用，都手工书写无参数构造方法

标准类制作
  1. 成员变量
    使用private修饰
  2. 构造方法
    提供一个无参构造方法
    提供一个带多个参数的构造方法
  3. 成员方法
    提供每一个成员变量对应的setXxx()/getXxx()
    提供一个显示对象信息的show()
  4. 创建对象并为其成员变量值的两种方式
    无参构造方法创建对象后使用setXxx()赋值
    使用带参构造方法直接创建带有属性值的对象

例子：

Student.java程序

public class Student{

​ prative String name;//成员变量

​ prative int age;

​ public Student() { }//构造方法

​ public Student(String name,int age){

​ this.name = name;

​ this.age = age;}

​ //成员方法

​ public void setName(String name){

​ this.name = name;}

​ public String getName(){

​ return name;}

​ public void setAge(int age){

​ this.age = age;}

​ public String getAge(){

​ return age;}

​ public void show(){

​ System.out.println(name+”,”+age);}

}

StudentDemo.java程序

package com.XXX

public class StudentDemo{

​ public static void main(String[ ] args){

​ //无参构造方法创建对象后使用setXxx()赋值

​ Student s1 = new Student( );

​ s1.setName(“xuan”);

​ s1.setAge(18);

​ s1.show();

​ //使用带参构造方法直接创建带有属性值的对象

​ Student s2 = new Student(“name:”xuan”,age:18);

​ s2.show();

​ }

}

运行结果：

xuan,18

xuan,18

Java 继承

继承的概念

继承是面向对象的三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，追加属性和方法

  • 格式:public class 子类名extends父类名}
  • 范例: public class Zi extends Fu
    Fu:是类，也被称为基类、超类
    Zi: 是子类，也被称为派生类

继承中子类的特点：

子类可以有父类的内容，还可以有自己特有的内容

继承的好处和弊端

继承好处
提高了代码的复用性(多个类相同的成员可以放到同一个类中)
提高了代码的维护性(如果方法的代码需要修改，修改一处即可)
继承弊端
继承让类与类之间产生了关系，类的合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性
什么时候使用继承?
继承体现的关系:is a
假设法:我有两个类A和B，如果他们满足A是B的一种，或者B是A的一种，就说明他们存在继承关系，这个时候就可以考虑使用继承来体现，否则就不滥用继承

继承中变量的访问特点

在子类方法中访问一个变量

  1. 子类局部范围找
  2. 子类成员范围找
  3. 父类成员范围找
  4. 如果都没有就报错(不考虑父亲的父亲…)

继承类型

需要注意的是 Java 不支持多继承，但支持多重继承。

img

继承关键字

继承可以使用 extends 和 implements 这两个关键字来实现继承，而且所有的类都是继承于 java.lang.Object，当一个类没有继承的两个关键字，则默认继承 Object（这个类在 java.lang 包中，所以不需要 import）祖先类。

extends关键字

在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类。

public class Animal {
private String name;
private int id;
public Animal(String myName, int myid) {
//初始化属性值
}
public void eat() { //吃东西方法的具体实现 }
public void sleep() { //睡觉方法的具体实现 }
}

public class Penguin extends Animal{
}

implements关键字

使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。

public interface A {
public void eat();
public void sleep();
}

public interface B {
public void show();
}

public class C implements A,B {
}

super 与 this 关键字

super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。

this关键字：指向自己的引用。

实例

class Animal {
void eat() {
System.out.println(“animal : eat”);
}
}

class Dog extends Animal {
void eat() {
System.out.println(“dog : eat”);
}
void eatTest() {
this.eat(); // this 调用自己的方法
super.eat(); // super 调用父类方法
}
}

public class Test {
public static void main(String[] args) {
Animal a = new Animal();
a.eat();
Dog d = new Dog();
d.eatTest();
}
}

输出结果为：

animal : eat
dog : eat
animal : eat

final 关键字

final 可以用来修饰变量（包括类属性、对象属性、局部变量和形参）、方法（包括类方法和对象方法）和类。

final修饰的特点

  • 修饰方法:表明该方法是最终方法，不能被重写
  • 修饰变量:表明该变量是常量，不能再次被赋值
  • 修饰类:表明该类是最终类，不能被继承

声明类：

final class 类名 {//类体}

声明方法：

修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}

注： final 定义的类，其中的属性、方法不是 final 的。

final修饰局部变量

变量是基本类型: final修饰指的是基本类型的数据值不能发生改变

变量是引用类型: final修饰指的是引用类型的地址值不能发生改变，但是地址里面的内容是可以发生改变的

static 关键字

static 关键字是静态的意思，可以修饰成员方法，成员变量
static 修饰的特点

  • 被类的所有对象共享
    这也是我们判断是否使用静态关键字的条件
  • 推荐使用类名调用

static 访问特点

静态成员方法只能访问静态成员和静态成员方法

Java 包

包主要用来对类和接口进行分类管理

包的定义格式

格式：package 包名；

范例：package com.first;

import 语句(导包)

在 Java 中，如果给出一个完整的限定名，包括包名、类名，那么 Java 编译器就可以很容易地定位到源代码或者类。import 语句就是用来提供一个合理的路径，使得编译器可以找到某个类。

例如，下面的命令行将会命令编译器载入 java_installation/java/io 路径下的所有类

import java.io.*;(import 包名)