Java SE 面向对象

Java SE 面向对象

• 面向对象的三大特性: 封装 继承 多态

  • （1）封装：保护内部的操作不被破坏；
  • （2）继承：在原本的基础之上继续进行扩充；
  • （3）多态：在一个指定的范围之内进行概念的转换。
  • 对于面向对象的开发来讲也分为三个过程：OOA（面向对象分析）、OOD（面向对象设计）、OOP（面向对象编程）。

• 方法就是封装的一种体现

• 方法的重载就是多态的一种体现

1.类与对象

1.1 类

•  类就是同一类事物的统称，如果将现实世界中的一个事物抽象成对象，类就是这类对象的统称。
•  类是构造对象时所依赖的规范。
•   类是封装对象的属性和行为的载体，反过来说具有相同属性和行为的一类实体被称为类。
•  类是一个模板，它描述一类对象的行为和状态。

1.2 对象

•  对象：对象是类的一个实例（对象不是找个女朋友），有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。现实生活中随处可见的一种事物就是对象。
•  对象分为两个部分：静态部分和动态部分；即属性与行为或者变量与方法；

1.3 类和对象的关系

• 对象和类的关系是特殊到一般，具体到抽象。
• 类：我们叫做 class 。
• 对象：我们叫做 Object , instance (实例)。

1.4 类定义与使用

类可以包含以下类型变量：

•   局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。

•   成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
  -   类变量：类变量也声明在类中，方法体之外，但必须声明为 static 类型。

•   成员方法：一个类可以拥有多个方法。

1.4.1 属性（叫成员变量）

• 属性用于定义该类或该类对象包含的数据或者说静态特征。
• 属性作用范围是整个类体
• 属性定义格式：在类中，所有方法和代码块之外
• 在定义成员变量时可以对其初始化，如果不对其初始化，Java使用默认的值对其初始化。(数值：0,0.0 char:\u0000, boolean:false, 所有引用类型:null)

[修饰符] 属性类型 属性名 [= 默认值] ;

1.4.2 成员方法

  方法则用于定义该类或该类的实例的行为特征和功能实现。

  面向对象****中，整个程序的基本单位是类，方法是从属于类的。

 方法定义格式和之前讲的方法相同，其实就是一个东西。

[修饰符] 方法返回值类型 方法名(形参列表) {
  方法体; 
}

1.4.3 引用类型

  Java 语言中除基本类型之外的变量类型都称之为引用类型。

  Java中的 对象 是通过 引用 对其操作的。

1.4.4 内存分析

栈：

• 1. 每个线程私有，不能实现线程间的共享！
• 2. 局部变量放置于栈中。 **
• 3. 栈是由系统自动分配，速度快！栈是一个连续的内存空间！

堆：

• \1. 放置new出来的对象！
• \2. 堆是一个不连续的内存空间，分配灵活，速度慢！

方法区：

• \1. 被所有线程共享！
• \2. 用来存放程序中永远是不变或唯一的内容。（类代码信息、静态变量、字符串常量）

1.4.2 类定义

public class 类名{  

}

实例：

public class Xcar {
    String name;
    String model;
    String type;
    String color;
    double price;

    public static void getRun(){
        System.out.println("跑");
    }
    public static void getSit(){
        System.out.println("坐");
    }
    public static void getRefuel(){
        System.out.println("#92");
    }

}

1.5 创建对象

  对象是根据类创建的。在Java中，使用关键字 new 来创建一个新的对象。创建对象需要以下4步：

• 声明：声明一个对象，包括对象名称和对象类型。
• 导包：import；给出一个完整的限定名，包括包名、类名，那么 Java 编译器就可以很容易地定位到源代码或者类。相同路径下可以省略；
• 实例化：使用关键字 new 来创建一个对象。
• 初始化：使用 new 创建对象时，会调用构造方法初始化对象。

类名称 对象名称 = new 类名称 () ;

下面是一个创建对象的例子：

public class CarTest02 {
    public static void main(String [] args){
        Xcar car = new Xcar();
        car.color="黑色";
        car.name="BWM";
        car.model="X6";
        car.type="RTG";
        car.price=35000000;
 
      	System.out.println(car.color);
        car.getRun();
        car.getSit();
        car.getRefuel();
    }
}

1.5.1 调用对象

• 当一个实例化对象产生之后，可以按照如下的方式进行类的操作：
  • 对象.属性名：表示调用类之中的属性；
  • 对象.方法名()：表示调用类之中的方法。
• 同一类的每个对象有不同的成员变量存储空间。
• 同一类的每个对象共享该类的方法。

  自定义的引用数据类型可以作为方法的参数列表，可以作为方法的返回值类型

1.5.2 构造器（构造方法）

• 构造器用于构造该类的实例。
• 用来为对象初始化信息的
• Java通过new关键字来调用构造器，从而返回该类的实例。
• 构造器是一种特殊的方法。

[修饰符] 类名(形参列表){ 
  //n条语句 
}

• new作用的事情:
  1.在堆中为对象开辟空间,成员变量跟随对象进入到堆内存中,赋默认值
  2.调用构造器为对象初始化信息
  3.将对象的地址返回给引用

要点：

• 通过new关键字调用！！
• **构造器有返回值，但也不能定义返回类型(**返回值的类型肯定是本类)，不能在构造器里使用带数据的return语句。
• 如果我们没有定义构造器，则系统会自动定义一个无参的构造函数。如果已定义则编译器不会添加！
• 构造器的方法名必须和类名一致！
• 构造器是特殊的方法,就可以构成方法的重载->构造器的重载
• 可以通过构造器使用创建对象的同时赋值,简化代码结构

构造函数不是没有返回值吗？为什么不能用void?

  规定。事实上，构造函数是有返回值的就是构造的对象。如此写法只是针对构造函数的特殊规定。

public class Puppy{
    public Puppy(){
    //构造器
    }
 
    public Puppy(String name){
        // 这个构造器仅有一个参数：name
    }
}
//不需要返回值类型不需要void
//可以使用return关键字,可以不使用

public class Constructor {
    public static void main(String[] args) {
        Person p=new Person("凝",18,'女',"学生");
        p.eat();
        System.out.println(p.name);
    }


}
class Person{
    String name;
    int age;
    char sex;
    String work;

    //构造器
    public Person(){

    }
    //有参构造方法
    public Person(String name,int age,char sex,String work){
        this.name=name;
        this.age=age;
        this.sex=sex;
        this.work=work;
    }

    //成员方法
    public void eat(){
        System.out.println("吃饭");
    }
}

1.5.3 练习

1.5.3.1 makercake 买蛋糕

Cake.java

/*
    蛋糕师制作蛋糕:
        事物: 蛋糕   蛋糕师
        类: 蛋糕类    蛋糕师类    测试类

        蛋糕类:
            属性 : 尺寸  口味   价格   ...
            功能 : 展示(打印所有成员属性的值)
 */
    public class Cake {

    int size;
    String taste;
    double price;

    public void show(){
        System.out.println(size+"寸的"+taste+"的，价钱为"+price+"的蛋糕");
    }

}

Maker.java

public class Maker {
    String name;
    int years;
//方法制作蛋糕
    public Cake makeCake(int size, String taste, double price){
        Cake c=new Cake();
        c.size=size;
        c.taste=taste;
        c.price=price;

        return c;//返回 制作好的蛋糕

    }
}

Demo3.java

/*
    测试类
    注意: 自定义的引用数据类型可以作为方法的参数列表可以作为方法的返回值类型
 */
public class Demo03 {
    public static void main(String[] args) {

        Maker m=new Maker();

        Cake cake=m.makeCake(8,"水果味",999);//将制作好的蛋糕赋值给cake
        cake.show();//展示蛋糕

    }
}

1.6 this

• this指代当前对象(new的对象)

• 1.构造器的首行,通过this(实参)调用本类中的其他构造器

  • this(实参)

• 2.区分同名变量问题 ->局部与成员之间同名问题

  • 默认就近原则
  • 在构造器中 :
    • 局部变量->方法的形参,方法内部自定义的局部变量
    • 成员变量同名时候: this.变量名->成员变量
    • this指代当前new的对象,在new某一个对象的时候,才会调用执行的构造器进行初始化信息,this就指代哪一个对象
  • 在方法中 :
    • 存在方法的局部变量与成员变量的同名的时候,依旧是通过this.指代成员
    • 在成员方法中this指代调用成员方法的对象
    • 当没有同名问题时候,指代成员时候,默认省略this.

• 注意:

  • 不要在构造器之间相互调用,可能造成死循环的效果
  • 成员是属于对象的,需要跟随对象才能使用(成员变量,成员方法)->因为成员变量存在与对象的堆内存中

public class ThisDemo04 {
    public static void main(String[] args) {

        Cat cat =new Cat("加肥","加菲猫","橘黄色");
        System.out.println("输出地址："+cat);
        cat.catchMouse();

        Cat cat2= new Cat("凝","布偶");
        cat2.catchMouse();
    }
}

class Cat{
    public String name;
    public String type;
    public String color;

    //构造器重载
    public Cat() {
    }

    public Cat(String name, String type) {
        //构造器中的参数与成员同名问题
        //就近原则
        this.name = name;
        this.type = type;
        System.out.println(this);
    }

    public Cat(String name, String type, String color) {
        //调用本类中的其他构造器
        //必须第一行
        this(name,type);
        this.color = color;
    }

    //抓老鼠
    public void catchMouse(){
        String name = "zhangsan";
        //在成员方法中,this指代调用当前成员方法的对象
        System.out.println(this.name+type+"正在捉老鼠");
    }
}