华清远见-重庆中心-JAVA面向对象阶段技术总结

最新推荐文章于 2024-07-21 22:27:18 发布

Cྀнєяιѕн

最新推荐文章于 2024-07-21 22:27:18 发布

阅读量366

点赞数 1

文章标签： java 开发语言

本文链接：https://blog.csdn.net/qq_62737752/article/details/127853568

版权

JAVA面向对象阶段技术总结

面向对象基础知识
方法总结

面向对象基础知识

两种编程思想

面向过程编程

Procedure Oriented Programming 简称POP
是一种基本的编程思想，是将一件事按流程逐步实现。
这种思想强调事情完成的过程，分析步骤写出相应的代码。
如猜数游戏，每一个步骤都是能按顺序用代码描述出来，逻辑清晰。
但如果逻辑复杂，如xxx管理系统，则无法使用POP的思想实现。
C语言就是一门标志性的面向过程编程语言。
Java基础部分写的所有代码，都是面向过程的，都是一步步按流程执行。
面向对象编程

面向对象编程

Object Oriented Programming 简称OOP
是当主流的编程思想，是创建解决问题的对象，赋予对象对应的行为和特征，让这些对象互相配合(调用
对象的方法)完成。
这种思想致力于将计算机中的世界，描述的和现实中一致的思想。

总结

面向过程：亲力亲为，侧重于分析完成事情的过程。
面向对象：所有事情交给相应的对象完成，侧重于如何创建解决问题的对象。

类和对象

类Class

具有相同属性和行为的对象的集合，称为"一类"。可以理解为模板。
属性：描述对象的特征，在程序中，通过定义变量的形式表现属性。
行为：描述对象的动作，在程序中，通过定义方法的形式表现行为。
在程序中，通过定义一个class来定义一个类。在类中定义变量描述属性，定义方法描述行为。

定义类

[修饰符] class 类名{
//属性(变量)
//行为(方法)
}

public class Car {
//定义属性
String brand;//品牌
String color;//颜色
int seat=5;//座位数
//定义行为
void go(){
   System.out.println("在行驶");
}
void stop(){
   System.out.println("停下来了");
}
void fly(){
   System.out.println("飞起来了");
 }
}

对象Object

对象是类的一个实例，是类的具体表现。

创建对象

类名对象名 = new 构造方法([参数])；
创建的对象，通过"."操作符访问类中的非私有属性和方法。

/*
* 创建工厂类(程序入口)，该类可以创建车的对象
* */
public class Factory {
  public static void main(String[] args) {
//类名 对象名 = new 类名([参数]);
//创建车类的对象c1
  Car c1 = new Car();
//给对象的属性赋值
  c1.brand = "宝马";
  c1.color = "白色";
    System.out.println("车名：" + c1.brand + "，颜色：" + c1.color + ",座位数："
    + c1.seat);
  c1.go();
  c1.fly();
  c1.stop();
  Car c2 = new Car();
  c2.brand = "五菱宏光";
  c2.color = "黑色";
  c2.seat = 7;
    System.out.println("我有一辆" + c2.seat + "座的" + c2.color + c2.brand);
  }
}

类和对象的关系

对象是类的具体表现，类是对象的集合(模板)。
如包饺子的模具就是一个类，每次用这个模具包出来的饺子都是一个一个对象。
先定义类，才能通过该类创建对象。

成员变量、成员变量和静态变量

成员变量

定义在类中的变量，称为成员变量，拥有默认值

数据类型	默认值
整型	0
浮点型	0.0
布尔型	false
字符型	空字符
引用类型(数组、类、接口)	null

局部变量

定义在方法中的变量，称为局部变量。默认有默认值，赋值后才能使用

public class Test{
  public static void main(String[] args){
//这里的num和name就是一个局部变量,没有默认值
  int num;
  System.out.println(num);//这里无法通过编译，因为num没有赋值
  String name="小明";
  System.out.println(name);//这样才能正常输出
}

静态变量

构造方法

概念

构造方法是一个特殊的方法，没有返回值，方法名和类名一致。
每个类在定义时，都有一个默认隐藏的无参数的构造方法，在创建对象时调用。
构造方法通常用于初始化成员变量。

public class Test{
//这就是无参数的构造方法，默认就会存在，不过是隐藏的
public Test(){
  }
}

特点

构造方法没有返回值(没有返回值这一部分，不是void)，构造方法名必须和类名相同
每个类默认有一个隐藏无参数的构造方法，方法体中没有内容，用于创建无参数的对象
如果自己写了有参数的构造方法，默认无参数的构造方法就会失效。如果想要同时拥有带参数和不
带参数的构造方法，就需要把它们都写出来
构造方法可以限制创建对象时的参数
构造方法不能通过“.”操作符访问，只能通过new关键字创建对象时自动调用，所以构造方法通常用
于初始化成员变量

面向对象三大特性

封装

使用private关键字对属性进行修饰。再对外提供一组公开的get/set方法用于对该属性读取或赋值。
可以防止除自身类之外的地方对该属性就行访问。
这样做可以保护关键属性，隐藏类内部的实现细节

步骤

创建类，编写成员变量，给成员变量添加private修饰符
给所有成员变量添加setXXX方法，用于给私有的成员变量赋值
给所有成员变量添加getXXX方法，用于读取私有的成员变量
这是创建对象后，无法通过.访问属性，只能通过get/set方法

public static void main(String[] args){
 Student stu = new Student();
//stu.stuId=111;无法通过.赋值和读取
//只能通过set方法赋值
 stu.setStuId(10026312);
//只能通过get方法获取私有属性的值
 System.out.println(stu.getStuId());
}

继承

类A可以通过extends关键字继承类B。
语法：class 类A extends 类B{}
类A称为子类、派生类、衍生类、subClass
类B称为父类、根类、超类、superClass
继承后，子类可以访问父类中非私有(没有被private修饰的内容)的属性和方法。
不同的子类中如果有相同的代码，都可以把它们提出来保存到父类中，从而减少子类中的代码冗余。
如狗类、猫类都有类型、昵称等属性，也有吃、睡等方法，那么就可以定义一个动物类，将这些公共的
属性和方法定义在动物类中，让猫类和狗类继承动物类。

继承的特点

如果多个类之中有相同或类似的代码，可以将这些代码提取出来定义在一个公共的类中，这个类就
是父类。再让那些类就继承这个父类，那些类就是子类，这样就能减少子类中的重复代码
子类对象可以直接访问父类中非私有(不用private修饰)的属性和方法
子类可以对父类中的方法进行扩展或覆盖，这称为方法重写。重写后，子类对象再调用该方法时，
执行的是重写后的内容
Java中是单继承。一个子类只能extends一个父类，一个父类可以有很多个子类
Java中可以多重继承。类A可以继承类B，类B可以继承类C，这时类A既是类B的子类，也可以称为
类C的子类，可以访问类B与类C中非私有的成员
任何类都是Object类的子类
在创建子类对象时，会先执行父类中相应的构造方法

重写Override

当子类继承父类后，可以对父类中非私有的方法进行扩展或覆盖，这个过程称为方法重写。

方法重写要求

方法名、参数列表、返回值必须和父类一致
访问权限不能比父类更严格(访问修饰符的范围要么一致要么更大)
不能抛出比父类更大的异常

重载Overload

在一个类中，如果多个方法的方法名相同，参数列表不同时，这些方法称为重载的方法。
同名不同参。
重载用于在一个类中，某个方法在不同的条件下，执行不同的内容

方法名相同
参数列表(参数类型和数量)不同
与返回值无关

this和super

这两个关键字，都可以当做对象使用，也可以当做构造方法使用。

当做对象使用

用法：“this.属性”或“this.方法”或“super.属性”或“super.方法”
此时的this或super表示“当前类”或"父类对象"

当做构造方法使用

用法：“this([参数])或super([参数])”
此时的this([参数])或super([参数])表示当前类或当前类的父类的某个构造方法。
如果当做构造方法使用时，只能写在另一个构造方法中的第一行

注意

如果父类中有无参数的构造方法，在子类的构造方法中，可以不写super()，系统会自动调用。
如果父类中有带参数的构造方法，没有无参数的构造方法，在子类的构造方法中，必须要写super()，并
且赋予适当的参数。
子类和父类都不写有参数的构造方法，都用默认的无参构造方法
父类中没有无参数的构造方法，子类中就必须调用父类中对应的构造方法

多态

概念

多态就是子类的对象指向父类的引用(子类对象使用父类变量接收，即向上转型)。
父类变量 = new 子类();

多态的应用

当某个方法的参数为父类变量时，可以传递一个子类对象。
这样就能在传递不同子类对象时，执行不同的方法。
如要调用动物发出叫声的方法，参数为猫，输出喵喵叫，参数为狗，输出汪汪叫。
不用多态，需要写多个重载的方法，参数为猫或狗的具体类型。
使用多态，只需一个方法，参数为动物类型，动物类中定义一个叫的方法，让猫和狗继承这个动物类，
重写叫的方法。
这时调用动物发出叫声的方法时，就会根据实际的参数，表示不同的结果。

多态的实现条件

在继承关系中
子类需要重写父类中的方法
父类的引用指向子类的对象(向上转型)

Object类

是Java中所有类的父类。每个类都是这个类的子类，但没有用extends体现出来。
该类中定义了很多方法，通常需要进行重写。

常用方法	返回值	作用
toString()	String	在输出某个对象时，会默认调用该方法。该方法默认输出“包名.类名@十六进制哈希码”。通常用于重写后输出对象的属性。
hashCode()	int	得到某个对象的哈希码。哈希码可以理解为对象内存地址通过一种算法转换得到的一个特定值。
getClass()	Class	得到某个对象的所在类。默认输出"class 包名.类名"
equals(Object obj)	boolean	判断两个对象是否相同。Object中默认用==比较对象，通常需要对其进行重写。
notify()	void	唤醒某个线程
notifyAll()	void	唤醒所有线程
wait(long time)	void	让线程休眠，直到被唤醒
finalize()	void	当某个对象被垃圾回收(GC)回收前执行的方法

对象造型/对象转型

类似于原始类型中的数据类型转换。对象A转换为对象B的过程称为对象造型或对象转型。
在非继承关系的两个对象中，无法实现转型。

向下转型

父类对象转换为子类对象的过程，称为向下转型。(强制转换)
转换方式：在要转换的对象前加上"(目标类型)

//一个Object类型的对象
Object obj = new Object();
//默认无法将父类对象保存到子类变量中
//Person p = obj;
//经过向下转型即可
Person p = (Person) obj;

向上转型

子类对象转换为父类对象的过程，称为向上转型。(自动转换)

访问修饰符

访问修饰符可以限制某个类、属性或方法的访问权限

访问修饰符	含义	可以修饰
public	公共的	类、属性、方法
protected	受保护的	属性、方法
不写	默认的	类、属性、方法
private	私有的	属性、方法

访问权限表

	同一个类中	同一个包中的不同类	不同包中的子类	不同包中的非子类
public	√	√	√	√
protected	√	√	√	×
不写	√	√	×	×
private	√	×	×	×

final关键字

修饰属性

当final修饰属性时，该属性的值不可更改。
定义属性时，在属性前加上final，这时的属性称为常量。常量命名时，所有字母都大写，多个单词之间
用_隔开。

final 数据类型 常量名;
final NUM = 123;
final PI = 3.14;

修饰方法

当final修饰方式时，该方法不能被重写。
定义方法时，在返回值前加上final。

public class Father{
  public final void fun(){
  }
}
  public class Son extends Father{
  //会报错，提示该方法不能被重写
  @Override
  public void fun(){
  }
}

修饰类

当final修饰类时，该类不能被继承。
定义类时，在class前加上final。

public final class Father{
}
//会报错，提示该Father类不能被继承
public class Son extends Father{
}

抽象abstract

修饰方法

使用： 访问修饰符 abstract 返回值类型方法名(参数类型形参名称);
如果一个方法的方法体无法描述，是由其子类进行重写，可以将该方法定义为抽象方法。
该抽象方法所在的类，也必须用abstract修饰，让其成为一个抽象类

//当一个类中有抽象方法时，该类也需要是一个抽象类
public abstract class Game{
//这就是一个抽象方法，没有方法体
public abstract void startGame(Player player);
}

修饰类

使用： 访问修饰符 abstract class 类名{}
如果一个类中有抽象方法，这个类必须也是一个抽象类。
抽象类不能被实例化(不能创建对象)。
抽象类中，可以存在非抽象方法，如getter/setter或构造方法。
当抽象类的构造方法执行时，不会创建对象。
当一个类不希望创建它本身对象或在它其中有抽象方法时，就将该类定义为抽象类。

abstract关键字特点

修饰类：被修饰的类称为抽象类

抽象类不能被实例化，无法创建对象。
抽象类中有构造方法，在创建其子类对象时，自动调用执行。
抽象类中可以有抽象方法，也可以有非抽象方法。
抽象类的子类要么继续成为抽象类，要么重写抽象父类中的所有抽象方法。

修饰方法：被修饰的方法称为抽象方法

抽象方法没有方法体。
抽象方法只能出现在抽象类或接口中。
abstract不能修饰构造方法和静态方法。

接口interface

在Java中，数据类型分为基本类型和引用类型。
引用类型包含：数组、类和接口。
所以接口是一种数据类型，类似于类，在定义接口的时候，用interface替换class。
由于Java是单继承，如果类A既要继承类B中的内容，也要继承类C中的内容时，
如果用“extends class名”，只能选择一个类继承，但如果使用**“implements interface名1,interface名
2…”，就能同时"继承"多个接口。**
通常用extends表示类A继承类B，用implements表示类A实现接口A,接口B…。
接口是一个完全抽象类。一个类可以同时implements实现(“继承”)多个接口。

extends和implements

类A extends 类B
类A当做类B的子类，继承。
类A implements 接口A，接口B…
类A当做接口A、接口B的实现类(“子类”)
接口A extends 接口B
接口A通过extends继承接口B
类A extends 类B implements 接口A，接口B…
类A是类B的子类，是接口A、接口B的实现类，同时能访问这三个"父类"中的数据。

什么时候使用接口

如果想要让某个类作为多个"类"的子类时，将这些"父类"定义为接口
如果某个类中的所有方法，都是抽象方法时，可以将这个抽象类改为接口

定义接口

public interface 接口名{
  //接口中只能定义公开的静态常量且要赋值，默认用public static final修饰
  double PI = 3.14;
  //接口中的方法默认用public abstract修饰，表示公开的抽象方法
  void fun(String name);
  //接口中不能定义普通方法
  //void fun1(){}
  //jdk1.8之后，接口中可以定义默认方法或静态方法，有方法体
  default void fun2(){
  }
  static void fun3(){
  }
}

接口的特点

接口中的属性默认被public static final修饰，表示公共的静态常量，需要赋值。使用时直接通过类
名访问。
接口中的方法默认被public abstract修饰，表示公共的抽象方法，没有方法体。
- JDK1.8后，接口中可以存在两种特殊的方法，都有方法体
  - 被default修饰的默认方法
  - 被static修饰的静态方法
接口中没有构造方法，不能创建对象。
接口通常需要子类实现，实现后必须重写其中的所有抽象方法。

抽象类和接口的异同

抽象类是一个类，用abstract class定义
- 有构造方法，不能创建对象，在创建子类对象时调用构造方法
- 抽象类中可以有抽象方法，也可以有普通方法
- 抽象类被子类继承时，使用extends关键字。子类必须重写父类中的所有抽象方法
- 子类只能继承一个抽象类
接口不是一个类，用interface定义
- 没有构造方法，不能创建对象
- 接口中的属性都是公共的静态常量
- 接口中的方法都是公共的抽象方法
- JDK1.8后，可以在接口中定义default方法和static方法

static静态的

static是一个修饰符，可以修饰属性、方法、代码块。
被static修饰的内容，称为静态成员。静态成员在类加载的时候，就会保存到内存中，可以脱离对象存
在。
所以访问静态成员时，可以不用创建对象，直接通过类名访问。如Math中的属性和方法都是静态的，所
以直接通过Math访问。

什么时候使用static

如果某个属性或方法被高度重用时，可以将其定义为static静态的。
这样这些属性就会脱离对象，在类加载时就加载到内存中，从而直接通过类名即可访问。
或不想创建对象就想使用该类中的属性或方法时，将它们定义为静态的。

静态常量

static修饰属性时，通常和final一起使用，表示静态常量

public class Person{
//静态常量
public final static String COUNTRY="中华人民共和国";
}
public class Test{
public static void main(String[] arg){
//静态成员直接通过类名访问
System.out.println(Person.COUNTRY);
}
}

静态方法

当某个方法被高度重用时，可以将其定义为静态的，之后通过类名调用。

public class Person{
public final static String COUNTRY="中华人民共和国";
//静态方法
public static void info(){
System.out.println("我来自于"+COUNTRY);
}
}
public class Test{
public static void main(String[] arg){
//静态成员直接通过类名访问
Person.info();
}
}

静态代码块

在类加载时自动执行的代码块。

public class Person{
//静态代码块
static {
//这里的代码在类加载时自动执行。
}
}

static特点

静态方法中只能使用静态成员，不能使用非静态成员

public class Student{
static String str="静态成员变量";
int num=123;//非静态成员变量
//静态方法中只能使用静态成员
public static void fun(){
System.out.println(str);//可以
//System.out.println(num);报错
}
}

非静态方法中可以使用静态成员

public class Student{
static String str="静态成员变量";
int num=123;//非静态成员变量
//非静态方法中可以使用静态成员
public void fun2(){
System.out.println(str);//可以
System.out.println(num);//可以
}
}