面向对象回顾

最新推荐文章于 2024-01-19 09:56:36 发布

System10010

最新推荐文章于 2024-01-19 09:56:36 发布

阅读量107

点赞数

面向对象阶段回顾

1. 类和对象

面向过程 -> 面向对象

**面向过程/面向方法/面向函数/结构化方法：**需要什么代码就写什么代码，代码需要复用演变出方法为基本单位。

访问修饰符   返回值类型   方法名(形式参数列表){
    // 方法体
}

public class xxx{
    // 模拟学生上学的方法
    起床、穿衣、洗脸刷牙、上学
    // 模拟老师上班的方法
   	起床、上班
}

**面向对象：**把功能进行聚合，以类和对象为组织单元进行结构编程。(需要一些时间起码1年以上的项目经验)

public class xxx{
    // 调用学生的方法
    // 调用老师的方法
}

public class Student{
    // 学生的信息
    // 学生起床方法
    // 学生穿衣方法
    .....
}

public class Teacher{
    // 老师起床方法
    // 老师上班方法
    .....
}

生活中的类和对象

万物皆对象：所有的事物都可以看作是一个对象。

描述生活中的对象通过对象的特征和行为进行描述。

分类：生活中我们习惯会进行分类，是按照一组对象的特征和行为抽象出来的。

类和对象的关系：类是对象抽象出来的一个概念，而对象是类的一个实例、个体(根据类的模板而产生的)。

计算机中的类和对象

Java是一个面向对象的编程语言，它将现实生活中的类和对象进行改造，以类为基本的项目组织单位。

public class 类名{
    // 一组特征(属性/成员变量/实例变量)
    public String name;
	// 一组行为(方法/函数/成员方法)
    public void print(){
        
    }
}

// 对象的创建
类名  对象名  =  new  类名();
// 对象属性的使用
对象名.属性名 = xxx;
// 对象方法的调用
对象名.方法名();

方法的基本使用

// 方法声明
访问修饰符   返回值类型   方法名(形式参数列表){
    // 方法体
}

无参无返方法的使用。

public  void 方法名(){
    // 方法内容  例如：吃货联盟的打印菜品信息方法     打印订单信息方法
}
// 调用方法
方法名();

// 1.在同一个类中  方法间的调用
// 1.1 都是实例/普通成员方法
直接方法名()调用即可。
// 1.2 其中一个是静态的(static)方法
静态方法无法直接调用实例方法
静态方法可以直接同1.1调用静态方法
实例方法可以直接调用静态方法

// 2.在不同类中  方法间的调用
// 2.1 调用其他类的实例方法
先创建对象  然后再调用该方法

2. 方法和方法重载

方法的四大分类

无参无返：往往用于固定的功能实现，且无需使用其实现结果的情况。

// out.println();
public void 方法名(){
    // 方法体
}

无参有返：往往用于固定的功能实现，需要使用其实现结果的情况。

// input.nextInt();
public  返回值类型  方法名(){
    // 方法体
    return 返回值;  
    // return 结束当前方法   返回到方法的调用位置
}

有参无返：需要根据参数来进行相应处理，处理完的结果无需再次被使用。

// Arrays.sort(数组);  调用完方法  数组已经排序结束  无需返回结果
public void 方法名(形式参数列表){
    // 方法体
}

有参有返：需要根据参数来进行相应处理，并且处理完的结果需要再次使用。

// String  Arrays.toString(数组);
public 返回值类型  方法名(形式参数列表){
    // 方法体
    return 返回值;
}

方法的参数为基本数据类型和引用数据类型

方法的参数为基本数据类型：传递的值的内容，传递过去之后与之前无关。

方法的参数为引用数据类型：传递的是地址值，传递过去之后多方引用同一块内容。

构造方法

Student stu = new Student();
Student();

构造方法的作用：用于对象的初始化。

// 构造方法默认是系统自动提供的(无参构造)
// 如果你自行定义了一个构造方法  则系统不再提供了
public 类名(){
    // 初始化内容
}

// 带参构造
public 类名(String name,int age){
    // 给成员变量赋值
    // stuName = name;
    // stuAge = age;
	this.name = name;
    this.age = age;
}

this关键字

this表示当前类的对象，谁在调用方法谁就是当前对象。

this是对象所以对象可以调用的它都可以调用。

this.属性名

this.方法名

this(); // 调用构造它必须出现在构造方法中的有效代码的第一行

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

如果成员变量和局部变量重名，通过this来进行区分。(python 用global)

定义的位置：

成员变量定义在类中方法外。

局部变量定义在类中方法内。

作用域：

成员变量在整个类中都有效。

局部变量只在定义它的方法内有效。

生命周期：

成员变量随着对象的创建而产生，随着对象的销毁而结束。

局部变量随着方法的压栈而产生，随着方法的弹栈而结束。

默认值：

成员变量有默认值，在对象创建时进行了初始化。

局部变量没有默认值，如果不赋值无法直接使用。

方法重载

在同一个类中，如果出现了方法名相同，参数列表不同的情况，则构成了方法重载，与返回值类型和访问修饰符无关。

public void method1(){
    
}
public int method1(int age){
    
}

3. 封装-三大特性之一

封装的作用

Dog dog = new Dog();

dog.age = 20000;

1.int类型取值范围

2.添加判断方法但是因为属性可以被任意访问，所以判断方法无法强制生效。

public class Dog{

	// public int age = if (age >１)
	public int age;

	public void setAge(int age){
		if(age > 15 || age < 0){
			this.age = 1; // 进行不合理赋值处理
		}else{
         	this.age = age;   
		}
	}

}

封装的使用

属性私有化
提供公共的setter和getter方法
根据需求在getter/setter方法中添加逻辑控制语句

public class Dog{
    private int age; // 以前  new Dog().age
    public void setAge(int age){
        // 判断
        this.age = age;
    }
    public int getAge(){
        return this.age;
    }
}

JavaBean规范(了解)

属性私有化
提供公共的getter/setter方法
提供无参构造
实现序列化接口 serializable

访问修饰符

修饰符\作用域(越来越松)	同一个类	同一个包	不同包子类	本项目中
private	1	0	0	0
默认	1	1	0	0
protected(继承)	1	1	1	0
public	1	1	1	1

包package

可以用于在一个项目中出现多个重名的类文件。

可以用于在一个项目中更清晰的对类文件进行区分。

可以用来做访问权限控制。

包的命名规范：全部小写，根据公司域名倒叙和公司内部规范来进行命名。

例如：com.tencent.tim.util

如果在包下定义类，那么此类中应该进行包声明。

package 包名;

如果两个类在同一个包中，可以直接使用。

如果两个类在不同包中，必须要先导包才能使用。(java.lang包下的类无需导入)

原因：因为不同包中可能有重名的文件，如果不指定类路径/全类名(cn.kgc.Test)，编译器无法区分。

import 要导入的类的全类名/全限定名/类路径。

注意：如果在一个类中使用到了两个不同包的同名类，那么必然有一个是需要以全类名形式使用的。

cn.kgc.demo1.Test1  test1 = new cn.kgc.demo1.Test1();

关键字static

静态的，类的

如果添加了static关键字，则此成员成为类的信息。

static修饰的信息和普通实例信息的区别：

static修饰的是属于类的，它被类的所有对象共享。

普通实例信息是对象之间相互独立的。

static修饰的信息是随着类的加载而加载，而普通实例信息是随着对象的创建而产生。

static可以用来修饰属性、方法、代码块。

成员/实例/构造/非静态代码块：{ // 代码内容 }

静态代码块：static{ }

构造方法、静态代码块、成员代码块的加载顺序：

静态代码块先进行加载，只会加载一次。

成员代码块每一次创建对象都会执行，优先于构造方法。

构造方法随着对象的创建而执行。

4. 继承-三大特性之一

public class Dog{
    private String name;
    private int health;
    private int love;
    private String strain;
    
    public void print(){
        syso(name health  love);
    }
}

public class Cat{
    private String name;
    private int health;
    private int love;
    private char gender;
    
    public void print(){
        syso(name health  love);
    }
}

继承：为了实现代码复用而产生的。 Java继承是单根继承，一个子类有且仅有一个父类，默认的父类是Object类。

父类：子类公有代码的聚合体。

子类：继承了公有代码聚合体的类。

子类 is a 父类

public class Pet{
    // 公有代码
}
public class Dog extends Pet{
    // 继承了公有代码
    // 特有的代码
}

子类并不是继承所有的父类信息：

私有的 private修饰的
构造的构造方法
不同包时默认修饰的(如果父类和子类不同包，但是父类中的某个信息还想被子类继承，必须加上protected修饰)
```
public class Pet{
    String name;
}
public class Dog extends Pet{
    public Dog(){
        super();
    }
}
```
super关键字

表示当前类的父类的对象。

super.属性

super.方法()

super()

当拥有继承关系之后，子类在调用构造时，会自动调用父类的无参构造。

5. 方法的重写

在子类继承了父类的方法之后，如果觉得父类的方法不太强大，可以根据需求进行重写。

方法名相同、参数列表相同、返回值类型相同或者为其子类(多态)，访问修饰符不能严于父类，抛出的异常不能比父类更大更多。

@Override 注解

方法重写和重载的区别

重写发生在继承关系的子类中。

重载发生在同一个类中。

重写：方法名相同、参数列表相同、返回值类型相同或者为其子类(多态)，访问修饰符不能严于父类，抛出的异常不能比父类更大更多。

重载：方法名相同、参数列表不同、与返回值类型和访问修饰符无关。

JDK中的重写应用

Object类：超类祖宗类 superclass 每一个类都直接或间接继承自Object。

equlas(); (我们是在字符串做比较时认识的)

public boolean equals(Object obj) {
	return (this == obj);
}

toString(); (out.print() 它底层在调用你输出内容的toString()方法)

public String toString() {
	return getClass().getName() + "@" + Integer.toHexString(hashCode());
}