类(三大特性)和对象

最新推荐文章于 2022-11-11 17:02:09 发布

捡头发的小灰灰

最新推荐文章于 2022-11-11 17:02:09 发布

阅读量820

点赞数

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/l_zerol/article/details/108126733

版权

java 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

文章内容输出来源：拉勾教育大数据开发高薪训练营

一、类和对象：

现实生活中，我们知道鸽子、鹦鹉、麻雀....，它们都有些共同的特征，比如都有翅膀、羽毛，都会飞(除个别)，我们把这些都有翅膀、羽毛，都会飞的统称为鸟类；

对象：是一个具体的概念，在现实生活中指客观存在的事物，比如上面的麻雀；在java中指的是内存空间中的一块存储区域；

类：是一个抽象的概念，简单来说就是“物以类聚”，就是对有相同特征和行为的多个对象的共同描述，在Java中体现为一种引用数据类型，包含了特征(属性)-成员变量,行为(方法)；

1. 类的定义：

class 类名{ 类体 ;} 类名有多个单词组成时每个单词首字母都要小写

// 定义一个类
public class Person {

}

/* 
class Zhangsan {

}
*/
注意：在java文件中，可以定义多个类，但是只能有一个类是public修饰的，并且这个类的类名必须与.java文件的名字完全相同（包括大小写）。

2. 创建对象：

new 关键字，本质就是在内存空间申请一块存储区域用于存放对象的独有信息；

// 定义一个类
public class Person {

    public static void main(String[] args) {

        // 创建一个Person对象
        Person p = new Person();
    }
}

3. 成员变量的初始值：

成员变量的类型	默认初始值
byte,short,int,long,float,double,char	0
boolean	false
引用类型	null

// 定义一个类
public class Person {

    // 定义成员变量
    String name;   // 默认初始值为null
    int age;       // 默认初始值为0

    public static void main(String[] args) {

        // 创建一个Person对象
        Person p = new Person();
    }
}

4. 成员方法:

4.1 定义:

class 类名{

返回值类型方法名(形参列表) {

方法体；

}

4.2 方法调用：引用变量名.方法名(实参)

4.3 方法的参数传递：

4.3.1 值传递与引用传递：

a. 基本数据类型的变量作为参数传递时，形参的数值改变不会影响到实参，因为而这有各自独立的变量空间；

b. 引用数据类型的变量作为参数传递时，形参指向内容的改变会影响到实参指向内容的数值，因为二者指向同一块内存空间；

4.3.2 可变长参数：

a. 定义：返回值类型方法名(参数类型... 参数名) { }；

b. 方法参数部分指定类型的参数个数可变，0~n；

c. 方法的形参列表最多只能声明一个可变长形参，且要放在参数列表的末尾；

5. 构造方法：

5.1 定义：类名(形参列表){ 构造方法体；} --没有返回值(包括void)且方法名必须与类名一致

5.2 作用：当用new实例化对象时会自动调用构造方法进行成员变量的初始化；是创建对象的途径。

// 定义一个类
public class Person {

    // 定义成员变量
    String name;   // 默认初始值为null
    int age;       // 默认初始值为0


    // 定义无参构造方法
    public Person() {

    }
    
    // 定义有参构造方法
    public Person(String name, int age) {

    }

    // 定义一个无参成员方法
    public void show() {
    
        System.out.println("我是" + name + ", 今年" + age + "岁");
    }

    // 定义一个有参成员方法
    public void print(int x) {
    
        System.out.println("传入的参数是：" + x );
    }


    public static void main(String[] args) {

        // 创建一个Person对象
        Person p = new Person();
        // 调用有参构造方法
        Person p1 = new Person("zhangsan", 13);        

        // 方法的调用
        p.show();
        p.print(3);
    }
}
问：构造器（构造方法）是创建java对象的途径，是不是说构造器完全负责创建java对象？

答：不是。构造器是创建java对象的重要途径，通过new 关键字调用构造器时，构造器也确实返回该类的对象，但是这个对象并不是完全由构造器负责创建的。实际上，当程序员调用构造器时，系统会先为该对象分配内存空间，并为这个对象执行默认初始化。这个时候对象已经产生了---这些操作在构造器执行之前就完成了。也就是说，在系统开始执行构造器的执行体之前，系统已经创建了一个对象，只是这个对象还不能被外部程序访问，只能在构造其中通过this来引用。当构造器的执行体结束后，这个对象作为构造器的返回值返回，通常赋给另一个引用变量，从而让外部程序可以访问该对象。

二、封装、继承、多态

1. 封装：java三大特性之一

概念：若出现对成员变量赋值一些合法但是不合理的数据，程序在编译运行阶段不会报错，这与显示不符；有时也为了保护私有数据不公开，就需要对成员变量进行包装处理，来隐藏对象内部的实现细节，就叫封装。

实现流程：

a. private 关键字私有化成员变量；

b. 提供共有set，get方法用来访问私有成员变量；

c. 在构造方法中用set方法进行合理判断；

// 定义一个类
public class Person {

    // 成员变量私有化
    private String name;   

    // 定义无参构造方法
    public Person() {

    }
    
    // 定义有参构造方法
    public Person(String name) {

        this.name = name;
    }

    // set方法
    public void setName(String name) {
        this.name = name;
    }
    // get方法
    public String getName() {
        return name;
    }

}

2. 继承(extends关键字)：java三大特性之二

2.1 概念：当多个类之间有相同的特征和行为时，可以将相同的内容提取出来组成一个公共类，让多个类吸收公共类中已有特征和行为，而在多个类型只需要编写自己独有特征和行为的机制，叫做继承。

2.2 使用继承的好处：

继承提高了代码的复用性，可维护性及扩展性，是多态的前提条件。

2.3 继承的特点：

a. 子类不能继承父类的构造方法和私有方法，但私有成员变量可以被继承只是不能直接访问。

b. 无论使用何种方式构造子类的对象时都会自动调用父类的无参构造方法，来初始化从父类中继承的成员变量，相当于在构造方法的第一行增加代码super()的效果。

c. 使用继承必须满足逻辑关系：子类 is a 父类。

d. java只支持单继承，子类只有一个父类，但父类可有多个子类。

2.4 方法的重写(Override)：

2.4.1 概念：

从父类中继承下来的方法不能满足子类本身的需求，就要在子类中重写一个和父类一样的方法，覆盖原先从父类中继承下来的方法，这种方式就叫重写。

2.4.2 重写规则：

a. 方法名相同、参数列表相同以及返回值类型相同(Java5开始允许返回子类类型);

b. 方法的访问权限不能变小，可以相同或者变大;

c. 方法不能抛出更大的异常(异常机制)；

2.5 方法的重载(Overload)：

2.5.1 重载规则：

方法名相同，参数列表不同(参数个数不同，参数类型不同，参数顺序不同)

2.5.2 应用：

可用于实现同一个方法的不同功能；

2.6 this关键字：

2.6.1 构造方法中使用，代表当前正在构造的对象；

2.6.2 成员方法中使用，代表当前正在调用的对象；

本质上this就是当前类类型的引用变量；

2.6.3 使用方式：

a. 局部变量名与当前类中的成员变量名相同，在方法体中优先使用局部变量(就近原则)，若要使用成员变量，则要在成员变量前加this关键字；(区分局部变量名与成员变量名相同)

b. 作为方法的返回值；

c. 在构造方法第一行使用this();调用本类中其他构造方法；

2.7 super关键字：

super指向的是当前对象的父类；在构造方法第一行使用super();调用父类中构造方法；

使用用例：

// 定义一个动物父类
public class Animal {
    private String name;

    public Animal() {
    }
    public Animal(String name) {
        setName(name);
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    
    public void show() {
       
        System.out.println("名字：" + getName());
    }
    
    /*
    // 这是重载的一种形式
    public void show(String s) {
        
    }
    */
}

// 定义一个子类 狗
public class Dog extends Animal {

    // 子类特有属性
    private int tooth;

    public Dog() {
        super(); // 表示调用父类的无参构造方法  自动保存
    }
    public Dog(String name, int tooth) {
        super(name); // 表示调用父类的有参构造方法
        setTooth(tooth);
    }

    public int getTooth() {
        return tooth;
    }
    public void setTooth(int tooth) {
        if (tooth > 0) {
            this.tooth = tooth;
        } else {
            System.out.println("牙齿数量不合理哦！！！");
        }
    }

    // 重写父类方法
    @Override
    public void show() {
        super.show();
        System.out.println("牙齿数量是：" + getTooth());
    }
}

3. 多态：java三大特性之三：

3.1 概念：同一事物表现的多种形态；

3.2 语法：父类引用指向子类对象；如：父类类型引用变量名 = new 子类类型();

注意：使用多态时，编译调用父类，运行调用子类；

3.3 特点：(重要)

a. 当父类类型的引用指向子类类型的对象时，父类类型的引用可以直接调用父类独有的方法。

b. 当父类类型的引用指向子类类型的对象时，父类类型的引用不可以直接调用子类独有的方法。

c. 对于父子类都有的非静态方法来说，编译阶段调用父类版本，运行阶段调用子类重写的版本（动态绑定）。

d. 对于父子类都有的静态方法来说，编译和运行阶段都调用父类版本。

3.4 引用数据类型的转换(发生在父类与子类之间)：

3.4.1 自动转换：小类型 ----> 大类型，子类 ----> 父类，向上转型

3.4.2 强制转换：大类型 ----> 小类型，父类 ----> 子类，向下转型

3.4.3 instanceof: 判断引用变量指向的对象是否为后面的数据类型；

3.5 多态的使用场合：

3.5.1 通过方法的参数传递形成多态；

public static void draw(Shape s) { s.show(); }

draw(new Rect(1, 2, 3, 4));

3.5.2 在方法体中直接使用多态的语法格式；

Account acc = new FixedAccount();

3.5.3 通过方法的返回值类型形成多态；

Calendar getInstance() { rerurn new GregorianCalendar(zone, aLocale); }

public class Test {

    public static void main(String[] args) {
    
        // 多态写法  父类引用指向子类对象
        Animal a = new Dog();
    }
}

四、static关键字

1. 基本概念：

static关键字修饰成员变量表示静态的含义，此时成员变量由对象层级提升为类层级，也就是整个类只有一份并被所有对象共享，该成员变量随着类的加载准备就绪(加载一次)，与是否创建对象无关。因为提升到类层级，所以可以直接通过类名.的方式调用。

2. 使用方式：

a. 在非静态成员方法中既能访问非静态的成员又能访问静态的成员。（成员包括成员变量，成员方法）；

b. 在静态成员方法中只能访问静态成员不能访问非静态成员。(因为此时可能还未创建对象，但静态成员随着类的加载而准备就绪)；

c. static 关键字只有隶属于类层级并被所有对象共享的时候才可以使用；

3. 构造块与静态代码块

3.1 构造块：

类体中直接使用{}括起来的代码块，每创建一个对象都会执行一次构造块。

3.2 静态代码块：

使用static关键字修饰的构造块，随着类加载时执行一次，之后不执行。

3.3 父类与子类中的执行流程：

父类的静态代码块 ----> 子类的静态代码块 ----> 父类的构造块 ----> 父类的构造方法 ----> 子类的构造块 ----> 子类的构造方法

3.4单例设计模式：

3.4.1 概念：

一个类对外提供且只提供一个对象时，这样的类叫做单例类，而设计单例的流程和思想叫做单例设计模式。

3.4.2 实现流程：

a. 私有化构造方法，使用private关键字修饰。

b. 声明本类类型的引用指向本类类型的对象，并使用private static关键字共同修饰。

c. 提供公有的get方法负责将对象返回出去，并使用public static关键字共同修饰。

3.4.3 分类：

饿汉式(声明时创建对象，后面直接将对象返回)、懒汉式(声明时赋值为null，后面返回的时候new一个对象返回；

// 单例设计模式
public class Singleton {
	
	// 声明本类类型的引用指向本类类型的对象，使用private static关键字共同修饰
	//private static Singleton sin = new Singleton();  // 饿汉式
	private static Singleton sin = null;               // 懒汉式
	
	// 私有化构造方法，使用private关键字修饰
	private Singleton() {}
	
	// 提供公有的get方法负责将对象返回出去，使用public static关键字共同修饰
	public static Singleton getInstance() {
		//return sin;
		if(null == sin) {
			sin = new Singleton();
		}
		return sin;
	}
}

五、final关键字

1 概念：

“不可变的”，可用来修饰类，成员变量，成员方法；

2 使用方式：

a. final关键字修饰的类不能被继承； -- 防止滥用继承

b. final关键字修饰的成员方法不能被重写但可以被继承；

c. final关键字修饰的成员变量必须初始化且不能改变；

3 常量：

public static final 修饰，并且常量名要求全部大写；

六、访问控制符：

修饰符	本类	同一个包的类	子类	其他类
public	√	√	√	√
protected	√	√	√	×
默认	√	√	×	×
private	√	×	×	×

捡头发的小灰灰

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
类(三大特性)和对象

一、类和对象：现实生活中，我们知道鸽子、鹦鹉、麻雀....，它们都有些共同的特征，比如都有翅膀、羽毛，都会飞(除个别)，我们把这些都有翅膀、羽毛，都会飞的统称为鸟类；对象：是一个具体的概念，在现实生活中指客观存在的事物，比如上面的麻雀；在java中指的是内存空间中的一块存储区域；类：是一个抽象的概念，简单来说就是“物以类聚”，就是对有相同特征和行为的多个对象的共同描述，在Java中体现为一种引用数据类型，包含了特征(属性)-成员变量,行为(方法)；1. 类的定义： class 类名..
复制链接

扫一扫