面向对象

发布于 2021-12-20  171 次阅读


面向对象

类与对象

类与对象的概括

类就是数据类型,比如cat

对象就是一个具体的实例

猫类(cat)-数据类型

属性

name ,age,color

行为

run,cry,eat

猫对象

对象(实例)

对象(实例)

例子

package xx;

public class xx {
	public static void main(String[]args){
		//创建一个对象(一只猫);
		Cat cat1=new Cat();
		cat1.name="猫口三三";
		cat1.age=5000;
		cat1.color="黄白";
		//第二只猫(对象);
		Cat cat2=new Cat();
		cat2.name="小白";
		cat2.age=10;
		cat2.color="白色";
		//访问东西
		System.out.println("第一只猫对象信息"+cat1.name+" "+cat1.age+" "+cat1.color);
		System.out.println("第二只猫对象信息"+cat2.name+" "+cat2.age+" "+cat2.color);
	}
}
class Cat{//自定义一个类
	String name;//名字
	int age;//年龄
	String color;//颜色
}

属性介绍

1.从概念或叫法上看:成员变量=属性=field(即 成员变量用来表示属性的)

属性是类的一个组成部分,一般是基本数据类型,也可是引用数据类型(对象,数据)、前面我们定义的猫类的 int age就是属性

细节

1.属性的定义语法同变量,如:访问修饰符 数据类型 属性名;

2.属性的定义类型可以为任意类型,包含基本类型或引用类型

3.属性如果不赋值,有默认值,规则和数组一致。

如何创建对象

1.先声明在创建

Cat cat;

cat=new Cat();

2.直接创建

Cat cat=new Cat();

访问属性

对象名.属性名;如cat.name; cat.age;

类和对象的内存分配机制

1.栈:一般存放基本数据类型(局部变量)

2.堆:存放对象(Cat cat,数组等)

3.方法区:常量池(常量,比如字符串)。类加载信息

Person p=new Person();
p.name="jack";
p.age=10;

1.先加载person类信息(属性和方法信息,只会加载一次)

2.在堆中分配空间,进行默认初始化;

3.把地址赋给p,p就指定对象

4.进行指定初始化,比如p.name-“jack” p.age=10;

成员方法

基本介绍

在某些情况下,我们需要定义成员方法(方法)。比如人类:除了有一些属性外(年龄,姓名.....)我们人类还有一些行为比如:可以说话,跑步,通过学习,还可以做算术题。这时就要用成员方法才能完成。

方法调用机制

1.当程序执行到方法时,就会开辟一个独立的空间(栈空间)

2.当方法执行完毕,或者执行到retum语句时,就会返回。

3.返回到调用方法的地方

4.返回后,继续执行方法后面的代码

5.当main方法(栈)执行完毕,整个程序退出

成员方法的定义

public 返回数据类型 方法名 (参数列表.......){

方法体语句;

return 返回值;

}

1.参数列表:表示成员方法输入 cal(int n)

2.数据类型 (返回类型):表示成员方法输出,,void 表示没有返回值

3.方法主体:表示为了实现某一功能代码块

4.return 语句不是必须的。

返回数据类型

1.一个方法最多有一个返回值(可以用数组来返回多个值)

2.返回类型可以为任意类型,包含基本数据类型或引用类型(数组,对象)

3.如果方法要求有返回数据类型,则方法中最后的执行语句必须为return值;而且要求返回值类型必须和return的值类型一致或兼容

4.如果方法时void,则方法体中可以没有return语句,或者只写return;

方法名:遵循驼峰命名法,最好见名知意,表达出该功能的意思即可,比如 得到俩个数的和getSun。开发中按照规范

形参列表

1.一个方法可以有0个参数,也可以有多个参数,中间用逗号隔开,

2.参数类型可以为任意类型,包含基本类型和引用类型

3.调用带参数的方法时,一定对应着参数列表传入相同类型或兼容类型的参数

4.方法定义时的参数称为形式参数,简称形参;方法调用时的参数称为实际参数,简称实参,实参,实参和形参的类型要一致或者兼容,个数,顺序,必须一致!

方法体

里面写完成功能的具体的语句,可以为输入,变量,运算,分支,循环,方法调用,但里面不能再定义方法!既:方法不能嵌套定义

方法调用说明

1.同一个类中的方法调用:直接调用即可;

2.跨类中的方法A类调用B类方法:需要通过对象调用。比如 对象名.方法名(参数);

3.跨类的方法调用和方法的访问修饰符相关。

11.17

克隆对象

package kl;
//克隆
public class kl {
	public static void main(String[]args){
			Wj a=new Wj();
			a.ue=20;
			a.nema="优依";
			Qsj aa=new Qsj();
			Wj a2=aa.boos(a);
		System.out.println("a.nema="+a.nema+"a.ue="+a.ue);
		System.out.println("==================================");
		System.out.println("a2.nema="+a2.nema+"a2.ue="+a2.ue);
		System.out.println(a==a2);
	}
}
class Wj{
	int ue;
	String nema;
}
class Qsj{
	public Wj boos(Wj a){
		Wj a2=new Wj();
		a2.nema=a.nema;
		a2.ue=a.ue;
		return a2;
	}
}

方法递归调用

递归重要规则

1.执行一个方法时,就创建一个新的受保护的独立空间(栈空间)

2.方法的局部变量是独立的,不会相互影响,比如n变量

3.如果方法中使用的是引用类型变量(比如数组,对象),就会共享该引用类型的数据

4.递归必须向退出递归的条件逼近,否则就是无限递归,出现StaKOverFlowError,死龟了;

5.当一个方法执行完毕,或者遇到return,就会返回,遵守谁调用,就将结果返回给谁,同时当方法执行完毕或者返回时,该方法也就执行完毕了。

方法重载

基本介绍

java中允许同一类中,多个同名方法的存在,但要求 形参列表不一致

重载的好处

1.减轻了起名的麻烦

2.减轻了记名的麻烦

例子

package pub;

public class fiheuehf {
	public static void main(String[]aegs){
		MyCalculator m=new MyCalculator();
		System.out.println(m.calculate(2, 3));
		System.out.println(m.calculate(2, 3.5));
		System.out.println(m.calculate(2.5, 3));
		System.out.println(m.calculate(2, 3,5));
 }
}
 class MyCalculator{
	 public int calculate(int n1,int n2){
		 	return n1+n2;
	 }
	 public double calculate(int n1,double n2){
			return n1+n2; 
			 }
	 public double calculate(double n1,int n2){
			 return n1+n2;
		}
	 public int calculate(int n1,int n2,int n3){
			 return n1+n2+n3;
		}
 }

使用细节

  1. 方法名:必须相同
  2. 参数列表:必须不同(参数类型或个数或顺序,至少有一样不同,参数名无要求)
  3. 返回类型:无要求

可变参数

基本概念

java允许将同一个类中多个同名同功能但参数个数不同的方法,封装成一个方法。

基本语法

访问修饰符 返回类型 方法名(数据类型...形参名){}

细节

1.可变参数的实参可以为0个或多个。

2.可变参数的实参可以为数组。

3.可变参数的本质就是数组。

4.可变参数可以和普通类型的参数一起放在形参列表,但必须保证可变参数在最后

5.一个形参列表中只能出现一个可变参数

例子

package tim;

public class Tm {
	public static void main(String[]args){
		mun m=new mun();
		System.out.println(m.ue("好耶", 90,60,90,80,75));
		System.out.println(m.ue("好耶", 90,60,90));
		System.out.println(m.ue("好耶", 90,60));
		
		
	}
}
	class mun{
		public String ue(String name,double...d1){
			double d2=0;
			for(int i=0;i<d1.length;i++){
				d2+=d1[i];
			}
			return name+"科目为"+d1.length+"门总成绩为"+d2;
		}
		public String ue(String name,double d1,double d2){
			double d3=d1+d2;
			
			return name+"科目为"+2+"门总成绩为"+d3;
		}
		public String ue(String name,double d1,double d2,double d3){
			double da=d1+d2+d3;
			
			return name+"科目为"+3+"门总成绩为"+da;
		}
	}

作用域

基本使用

1.在java编程中,主要的变量就是属性(成员变量)和局部变量。

2.我们说的局部变量一般是指在成员方法中定义的变量。

3.java中的作用域的分类

全局变量:也就是属性,作用域为整个类体;

局部变量:也就是除了属性之外的其他变量,作用域为定义它的代码块中!

4.全局变量可以不赋值,直接使用,因为有默认值,局部变量必须赋值后,才能使用,因为没有默认值。

细节

1.属性和局部变量可以重名,访问时遵循就近原则。

2.在同一作用域中,比如在同一成员方法中,两个局部变量,不能重名。

3.属性生命周期较长,伴随着对象的创建而且建立,伴随着对象的销毁而销毁,局部变量,生命周期较短,伴随着它的代码块的执行而创建,伴随着代码块的结束而销毁。即在一次方法调用过程中。

4.作用域不同

全局变量:可以被本类使用,或其他类使用(通过对象调用)

局部变量:只能在本类中对应的方法中使用

5.修饰符不同

全局变量/属性可以加修饰符

局部变量不可以加修饰符

例子

package zy;

public class Zyy {
	public static void main(String[]args){
		Yu ui=new Yu();
			ui.yu();
		Yu i=new Yu();
			 i.ue();
	}
}
	class Yu{
		public int htu=20;
		int tu;
		public void yu(){
			int htu=10;
			//int tu;//会报错
			//int htu=20;//报错
			System.out.println(htu);//输出10
				}
		public void ue(){
			tu=30;
			System.out.println(tu);
		}
	}

构造器

基本语法

[修饰符] 方法名(形参列表){

方法体;

}

说明

1.构造器的修饰符可以默认

2.构造器没有返回值

3.方法名 和类名字必须一样

4.参数列表 和成员方法一样的规则

5.构造器的调用,系统完成

基本介绍

构造方法又叫构造器,是类的一种特殊的方法,他主要作用是完成对新对象的初始化。它有几个特点:

1.方法名和类名相同

2.没有返回值

3.在创建对象时,系统会自动的调用该类的构造器完成对对象的初始化。

细节

1..一个类可以定义多个不同的构造器,即构造器重载

2.构造器名和类名要相同

3.构造器没有返回值

4.构造器是完成对象的初始化,并不是创建对象

5.在创建对象时,系统自动的调用该类的构造方法

6.如果程序员没有定义构造方法,系统会自动给类生成一个默认无参构造方法(也叫默认构造方法)。比如:Person(){}

7.一旦定义了自己的构造器,默认的构造器就覆盖了,就不能再使用默认的无参构造器,除非显式的定义一下,即:Person(){}

对象创建过程

package gzq;

public class Gzq {
	public static void main(String[]args){
		Ue p=new Ue("祈曦",20);
		
	}
}
	class Ue{
		String nema;
		int age=90;
		public Ue(String n,int a){
			nema=n;
			age=a;
		}
	}
/*流程分析
 * 1.加载Ue类信息(Ue.class),只会加载一次
 * 2.在堆中分配空间(地址)
 * 3.完成对象初始化[3.1默认初始化 age=0  name=null  3.2显式初始化  age=90,name=null,
 * 3.3构造器的初始化 age=20,name=祈曦]
 * 4.在对象在堆中的地址,返回给p(p是对象名,也可以理解成是对象的引用)
*/

this关键字

1.this关键字可以用来访问本类的属性,方法,构造器

2.this用于区分当前类的属性和局部变量

3.访问成员方法的语法:this.方法名(参数列表);

4.访问构造器语法:this(参数列表);注意只能在构造器中使用

5.this不能在类定义的外部使用,只能在类定义的方法中使用。

包的三大作用

1.区分相同名字的类

2.当类很多时,可以很好的管理类

3.控制访问范围

包基本语法

packge com.hspedu;

说明:

1.package关键字,表示打包,

2.com.hspedu表示包名

包的命名

命名规则:

只能包含数字,字母,下划线,小圆点,但不能用数字开头,不能是关键字和保留字

demo.class.exec1//class是关键字

demo.12a//不能数字开头

demo.ab12.oa//可以

命名规范

一般是小写字母+小圆点一般是com.公司名.项目名.业务 模块名

比如:com.hspedu.oa.model;

举例:

com.sina.crm.user//用户模块

com.sina.crm.order//订单模块

com.sina.crm.utils//工具类

常用的包

一个包下,包含很多的类,java中常用的包有:

java.lang.//lang包是基本包,默认引入,不需要再引入

java.util //util包,系统提供的工具包,工具类,使用Scanner

java.net //网络包,网络开发

java.awt //是做java的界面开发,Gul

访问修饰符

类别

java提供的四种访问修饰符号控制方法和属性(成员变量)的访问权限(范围):

1.公开级别:用public 修饰,多外公开

2.受保护级别:用protected修饰,对子类和同一个包中的类公开

3.默认级别:没有修饰符号,向同一个包的类公开

4.私有级别:用private修饰,只有类本身可以访问,不对外公开

使用的注意事项

1.修饰符可以用来修饰类中的属性,成员方法,以及类

2.只有默认的和public才能修饰类!,并且遵循上述访问权限的特点

3.子类直接不能访问私有的属性,方法,构造器

4.成员方法的访问规则和属性完全一样

封装

封装就是把抽象出的数据[属性]和对数据的操作[方法]封装在一起,数据被保护在内部,程序的其他部分只有通过被授权的操作[方法],才能对数据进行操作。

封装的理解和好处

1.隐藏实现的细节:方法(连接数据库)<--调用(传入参数..)

2.可以对数据进行验证,保证安全合理

封装的实现步骤

1.将属性进行私有化【不能直接修改属性】

2.提供一个公共的set方法,用于对属性判断并赋值

public void setXxx(类型 参数名){

//加入数据验证的业务逻辑

属性=参数名;}


3.提供一个公共的get方法,用于获取属性的值

public XX getXxx(){//权限判断
return XX ;

}

继承

继承的基本语法

class子类 extends 父类 {}

1.子类就会自动用于父类定义的属性和方法

2.父类又叫超类,基类

3.子类又叫派生类

细节

1.子类继承了所以的属性和方法,但私有属性不能在子类直接访问,要通过公共的方法去访问

2.子类必须调用父类的构造器,完成对父类的初始化

3.当创建子类对象时,不管使用子类的哪个构造器,默认情况下总会去调用父类的无参构造器名,如果父类没有提供无参构造器,则必须在子类的构造器中用super去指定使用父类的哪个构造器完成对父类的初始化,否则,编译不通过

4.如果希望指定去调用父类的某个构造器,则显式的调用下

5.super在使用时,需要放在构造器第一行

6.super()和this()都只能放在构造器第一行,因此这两个方法不能共存在一个构造器

7.java所有类都是Object类的子类

8.父类构造器的调用不限于直接父类!将一直往上追溯直到Object类(顶级父类)

9.子类最多只能继承一个父类(指直接继承),即java中是单继承机制

10.不能滥用继承,子类和父类之间必须满足is-a的逻辑关系

super关键字

基本介绍

super代表父类的引用,用于访问父类的属性,方法,构造器

基本语法

1.访问父类的属性,但不能访问父类的private属性 super.属性名

2. 访问父类的方法,但不能访问父类的private属性 super.方法名(参数列表)

3.访问父类的构造器 super(参数列表)只能放在构造器的第一句,只能出现一句

细节

1.调用父类的构造器的好处(分工明确,父类属性由父类初始化,子类的属性由子类初始化)

2.当子类中有和父类中的成员(属性和方法)重名时,为了访问父类的成员,必须通过super,如果没有重名,使用super,this,直接访问是一样的效果

3.super的访问不限制直接父类,如果爷爷类和本类中有同名的成员,也可以使用super去访问爷爷类的成员;如果多个基类中都有同名的成员,使用super访问遵循就近原则

No.区别点thissuper
1访问属性访问本类中的属性,如果本类没有
此属性则从父类中继承查找
访问父类的属性
2调用方法 访问本类中的方法,如果本类没有
此方法则从父类中继承查找
直接访问父类的方法
3调用构造器调用本类的构造器,必须放在构造器的首行调用父类的构造器,必须放在子类构造器的首行
4特殊表示当前对象子类中访问父类对象
super和this的比较

重写/覆盖

基本介绍

方法覆盖就是子类有一个方法,和父类的某个方法的名称,返回类型,参数一样,那么我们就说子类的这个方法覆盖了父类的那个方法

细节

1.子类的方法的参数,方法名称,要和父类方法的参数,方法名称完全一样。

2.子类方法的返回类型和父类方法的返回类型一样,或者是父类返回类型的子类 比如父类返回类型是object 子类返回类型是String

3.子类方法不能缩小父类方法的访问权限

名称发生范围方法名形参列表返回类型修饰符
重载本类必须一样类型,个数或者顺
序至少有一个不同
无要求无要求
重写父子类必须一样相同子类重写的方法,返回的类型
和父类的返回的类型一致,
或者是其子类
子类方法不能缩小
父类方法的访问范围
重写和重载的比较

多态

基本介绍

方法或者对象具有多种形态。是面向对象的第三大特征,多态是建立在封装和继承基础之上的

对象的多态

1.一个对象的编译类型和运行类型可以不 一致

2.编译类型在定义对象时,就确定了,不能改变

3.运行类型是可以变化的

4.编译类型是看定义是=号左边,运行类型看=号的右边

细节

多态的前提是:两个对象(类)存在继承关系

属性没有重写;属性的值看编译类型

多态的向上转型

1.本质:父类的引用指向了子类的对象

2.语法:父类类型 引用名 =new 子类类型();

3.特点:编译类型看左边,运行类型看右边。可以调用父类中的所有成员(需遵循访问权限),不能调用子类中特有成员;(最终运行效果看子类的具体实现)

多态的向下转型

1.语法:子类类型 引用名 =(子类类型)父类引用;

2.只能强转父类的引用,不能强转父类的对象

3.要求父类的引用必须指向的是当到当前目标类型的对象

4.可以调用子类类型中所有的成员

动态绑定机制

1.当调用对象方法的时候,该方法会和该对象的内存地址/运行类型绑定

2.当调用对象属性时,没有动态绑定机制,哪里声明,哪里使用

多态数组

介绍

数组的定义类型为父类类型,里面保存的实际元素类型为子类类型

说明

父类名[] 引用名字=new 父类名[大小];

引用名[下标]=new 父类自己/子类(实参);

多态参数

说明

方法定义的形参类型为父类类型,实参类型允许为子类类型

例子

   public static void main(String[] args) {
        Ue ue = new Ue();
        ue.U(ue);
    }
}
    class Qsj {
        
    }
    class Ue extends Qsj{
    public void U(Qsj q){
    
    }
}

equals方法

==和equals的对比

==是一个比较运算符

1.==:即可以判断基本类型,又可以判断引用类型

2.==:如果判断基本类型,判断的是值是否相等。

3.==:如果判断引用类型,判断的是地址是否相等,即判断是不是同一个对象4.

4.equals:是object类中的方法,只能判断引用类型

5.默认判断的是地址是否相等,子类中往往重写该方法,用于判断内容是否相等,比如Integer,String

equals重写

public class Cseq {
    public static void main(String[] args) {
        Shux shux1 = new Shux("qi", 10, 'n');
        Shux shux2 = new Shux("qi", 10, 'n');
        System.out.println(shux1.equals(shux2));
    }
}
class Shux  {
      private String name;
      private int age;
      private char gender;

    public Shux(String name, int age, char gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public char getGender() {
        return gender;
    }

    public void setGender(char gender) {
        this.gender = gender;
    }

    public boolean equals(Object obj) {
        if (this == obj){
            return true;
        }
        if (obj instanceof Shux){
            Shux s=(Shux)obj;
            return this.name.equals(s.name)&&this.age==s.age&&this.gender==s.gender;
        }
        return false;
    }
    }

hashCode方法

1.提高具有哈希结构的容量的效率!

2.俩个引用,如果指向的是同一个对象,而哈希值肯定是一样的

3. 俩个引用,如果指向的不是同一个对象,则哈希值肯定是不一样的

4.哈希值主要是根据地址号来的,不能完全将哈希值等价于地址

5.后面也会重写

toString

基本介绍

默认返回:全类名+@哈希值的十六进制,子类往往重写toString方法,用于返回对象的属性信息

当直接输出一个对象时,toString方法会被默认的调用

finalize

1.当对象被回收时,系统自动调用该对象的finalize方法,子类可以重写该方法,做一些释放资源的操作

2.什么时候被回收:当某个对象没有任何引用时,则jvm就认为这个对象是个垃圾对象,就会使用垃圾回收机制来销毁该对象,在销毁该对象前,会先调用finalize方法

3.垃圾回收机制的调用,是由系统决定的,也可以通过System.gc()主动触发垃圾回收机制,

断点调试

1.在开发中,可以用断点调试一步一步的看源码执行过程,从而发现错误所在

2.重要提示:在断点调试 过程中,是运行状态,是以对象的运行类型来执行的

介绍

1.断点调试是指在程序的某一行设置一个断点,调试时,程序运行到这一行就会停住,然后你可以一步一步往下调试,调试过程中可以看给个变量当前的值,出错的话,调试到出错的代码行即显示错误,停下,进行分析从而找到这个bug

3.断点调试也能帮助我们查看java底层源代码的执行过程,提高程序员的java水平

断点调试的快捷键

F7(跳入)F8(跳过)shift+F8(调出)F9(resume执行到下一次断点)

F7:跳入方法内

F8:逐行执行代码

shift+F8:调出方法