Java基础知识点(类和对象、方法、封装、继承、多态、抽象类和接口)

一、类和对象

1.类是什么?对象又是什么?类和对象的关系又是什么?

类就是一类事物的抽象概念,它不指代某一个具体的事物,而是将这一类事物所具有的特点进行抽取,然后形成一个带有范围指向性的概念。

对象就是某一类中的具体的指代,表示的是一个实实在在的具体的事物。由类生成对象的过程叫做实例化。

类是具有相同属性和行为的对象的集合或者说统称。

对象是由类创建出来的一个实体。这个实体所具备的属性和行为已经被类所规定好了。没有类,就无法创建对象。

实体类:现实世界中存在的

功能测试类:描述逻辑关系的,世界是由类和对象组成的。

类的创建:属性(名词)、方法(动词)。

线上模拟线下业务的步骤:
1.先分类 :实体类
2.用变量表示他们的详细信息
3.处理数据(赋值,取值)

2.单元测试:

@Test(可以像主方法一样点击执行)
1.方法必须是公共的public
2.不能有返回值,不能有参数
3.不能和主方法相互调用。

要想使用单元测试需要做一下几点:
需要在IDEA文件夹中的lib中把hamcrest-core-1.3.jar和junit-4.12.jar
放入项目与src并列创建的lib的文件夹中,然后选中Add as Library…

单元测试中要使用Scanner方法需要:
help》Edit Custom VM Options…
里面最后一行加上:-Deditable.java.console=true

3.输出简洁方式

%s表示字符串 %d表示整数 %f表示小数

System.out.printf(“大家好,我是%s,我是个%s的,我今年%d岁,我的颜值%.2f,乖巧值是%.3f,”name,sex,age,yanzhi,cute);

.2表示小数后保留两位小数
.3表示小数后保留三位小数

4.类:

实参就是给形参赋值的
返回值:方法的产出物
参数:进入方法所需的原材料

main方法中调用其它方法:
1.实例化对象,通过构造方法(虚拟机开辟内存行为),得到一个类的对象。
2.对象调用方法。

凡是被static修饰的方法或属性都是属于类的势力(可使用)范围
没有static修饰的就是对象的可使用范围

二、方法

1.方法的组成:

修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2,......){ 
	执行语句
	1.方法的调用
	2.变量的操作:声明 赋值  修改
	3.程序结构:选择结构 循环结构……… 
	return 返回值;
}

2.修饰符:

1.访问(调用)权限修饰符 public 公共的,这个项目都可以用。Private 私有的,仅限当前类可用。

2.静态修饰符:static

3.返回值类型:

1.void没有返回值

2.有返回值:返回一个基本类型数据或引用类型数据(类、数组)

4.方法名:

第一个单词小写,第二个以及后续单词首字母大写,字母、下划线、数字组成。

5.参数:

可以没有,也可以有,参数的声明同变量的声明,仅仅只是定义类型,取名字,不赋值。

1.参数的分类:形参,实参。

2.形参和实参的关系:实参是给形参赋值的

3.形参和实参保持个数一致类型一致。

4.形参的使用范围:相当于方法体中声明的局部变量

扩展:可变形参数组:
1.声明方式 类型…参数名
2.如果还需要其他参数,将可变形参数组放在最后面
3.可以用length属性获取可变参数的个数
4.可变参数可以不传值

Static属于类的,所有对象公共的,共有一份。
实例的,每个对象单独拥有一份。

6.调用:

Static静态的,属于类的,通过类名调用。
实例的,属于对象的,通过对象来调用。
注意:类名只能调用静态的,对象即可调用实例的,也可以调用静态的。

Public class Person{
int a=0;//实例 有多个变量
static int b=0; //静态 只有一份。
psvm {
sout (Person.b);
sout(Person.a)错
Person p1=new Person();
p1.b=6; p1.a=6;
Person p2=new Person();
sout(p2.b)//6 so
ut(p2.a);//10
}
}
实例方法:public void fun1(){}
静态方法:public static void fun2(){}

同类中:
1.静态方法调用静态方法 类名.静态方法(),可以省略类名。
2.静态方法调用实例方法 对象名.实例方法();
3.实例方法调用实例方法
一.this.实例方法() 可以省略this(当前对象) 二.实例对象.实例方法()
4.实例方法调用静态方法 类名.静态方法() 可以省略类名

不同类中:
1.静态方法中调用另一个类的静态方法 类名.静态方法()
2.静态方法中调用另一个类的实例方法 对象名.实例方法()
3.实例方法中调用另一个类的实例方法 对象名.实例方法()
4.实例方法中调用另一个类的静态方法 类名.静态方法()

7.构造方法:

1.每一个类都自带一个无参构造方法

2.构造方法返回值和方法重复的,因此省略了

3.有参构造:参数就是用来给成员属性赋值的

4.无参构造
引用数据类型的成员属性,默认值是null
无参构造创建的对象,属性都是没有赋值的,只有默认值。
有参构造创建的对象,同时也需要赋值。

8.重载:

同一类,方法同名不同参
不同类,参数个数不同,类型不同,顺序不同。

对象数组:User[] users={u1,u2,u3};
//增强for输出:for(User u:users){
sout(u.name+”–”+u.age)
}

对象数组作为方法的参数 addAge(users);
对象可以创建变量来接收值:Goods g=init();

三、封装和继承

1.封装:

为什么要封装:隐蔽性、安全性。

封装步骤:
1.成员属性私有(前面加个private)
2.提供公共的get(getter)和 set(setter)方法

//setter赋值
public void setSex(char sex){
this.sex=sex;
}

//getter获取
public char getSex(){
Return this.sex;
}

在这里插入图片描述

2.包:

导包:导入自己的包和系统的包

java.lang包是java语言的核心它提供了java中的基础类。(java.lang这个包属于系统包,该包中的类不用导入,例如System,String)

在这里插入图片描述

3.访问修饰符:

下图中:受保护的情况(protected) :子类必须在同一个包中。

在这里插入图片描述
类的访问修饰符:
Public:对外公开
默认:所在包有效,包以外不能访问 --体现在构造方法上

成员访问修饰符(成员属性和成员方法)
Public:对外公开
Protected:受保护的,同一个包的子类可以访问。
默认:同一个包中可以访问
Private:只在当前类有效

4.static和this关键字

所有被static修饰的,都会随着类的加载而加载。
所有的实例,都会因为对象的创建而加载
Static修饰的,属于类范围的,this代表当前对象。
Static修饰成员属性和方法和代码块

this的含义:
1.表示当前对象–出现在实例方法中
2.表示其他构造方法–出现在构造方法中,必须在第一行
注意:this不能出现在静态方法中

5.继承:

1.在多个子类中抽取出相同的属性和方法,形成父类的属性和方法
2.对父类成员的继承使用(包含成员属性和成员方法)

抽取出共有的重复的代码,使用继承,提高代码的复用性,

让类与类之间产生关系:extends

继承是两个类之间产生关联关系的唯一的方式

子类构造方法会默认调用父类构造方法。

为多态提供了前提

Java中支持单继承:一个子类只能有一个直接父类

Java中不支持多继承

6.this和super的区别:

this:
1.本类成员方法中,访问本类成员变量,访问本类另一个成员方法
2.本类构造方法中,访问本类另一个构造方法

super:
1.在子类成员方法中,访问父类成员变量和成员方法
2.在子类构造方法中,访问父类构造方法

本类的成员变量和局部变量重名,用this区分,
本类的成员变量和父类的变量重名,用super区分

7.重写(覆盖)和重载:

重载:同一个类中,方法名相同方法参数不同,典型应用:无参构造和有参构造

重写:子类和父类同名的方法。

子类方法和父类方法同名,子类方法会覆盖父类方法,称为重写(覆盖),前提,子类方法访问权限必须大于或等于父类方法的访问权限

8.Final:

修饰的变量称为常量,值不能被修改
修饰的方法不能被重写,保证安全性和稳定性
修饰的类不能被继承,避免功能被覆盖。

9.要想让一个类不被其它类继承:

1.用final修饰

构造方法私有化

10.继承总结:

访问修饰符:
Public:整个项目
默认的:同一个包
Protected:同一个包,子类中可以用
Private:当前类

Static:静态的,仅有一份,属于类的,所有对象公共的
This:实例方法–当前对象this.属性/方法,构造方法–其他构造方法this();
Super:实例方法中–父类对象super.父类属性/父类方法,构造方法–父类构造方法this();

继承:
1.类和类的关系:包含、附属。
2.抽取相同的属性和方法放在父类中,让子类去继承使用。
方法的重写:覆盖
子类和父类中同名的方法
子类功能比父类功能强大

四、多态

1.重写object类的equals方法

1.Object类的equals()方法:
比较两个对象是否是同一个对象,是则返回true
Object类是所有类的父类,它的equals方法自然会被所有类继承,有一个子 类String对equals方法进行了覆盖(重写),使其具有了新功能

2.操作符==
简单数据类型或常量值,直接比较值。
引用类型,比较是否为同一个对象。
(1)Object类的equals()方法和两个 = 没区别
(2)Java.lang.String重写了equals()方法,把equals()方法的判断变为了判断其值
(3)当有特殊需求,如认为属性相同即为同一对象时,需要重写equals()

案例:
1.分析String类时如何重写equals方法的。
2.在Pet类中重写equals方法

总结:
1.基本数据类型数据值只能用两个=
2.对于引用数据类型,两个 = 和Object的equals方法是一样的。
3.由于String类对父类Object的equals方法的重写,导致==与equals唯一的区别在于:
在这里插入图片描述

2.instanceof

java中的instanceof运算符是用来在运行时指出对象是否是特定类的一个实例。instanceof通过返回一个布尔值来指出,这个对象是否是这个特定类或者是它的子类的一个实例
使用格式: 对象 instanceof 类
使用解析:
形参 和实参 和 右边的类型
主要是看实参对象是否属于右边的类型

3.多态

封装以后,我们可以使用两种方式为对象属性赋值,set方法和有参构造。
什么时候使用set,什么时候使用有参构造。
Set可以在创建对象以后,反复的对属性值进行修改。而有参构造是在产生对象的同时就为属性赋值,且同一个对象只能使用一次。

1.什么是多态?
//把子类的实例化对象赋值给父类的引用类型
继承 Fu f=new Zi(); Pet p=new Dog(); Pet p=new Penguin();
重写 f.a();
多种状态 多态=继承+重写

2.案例理解:
1.使用多态实现宠物看病
2.使用多态实现宠物喂食。
3.捐献宠物系统

应用:
1.父类作为方法的形参 (多态最常用的使用方式)
案例:狗狗和企鹅都有看病的方法,如果健康值<50,主人就带它们去看病。
2.父类作为方法的返回值

例:捐献动物

Fu f=new Zi();
父类—静态方法 子类—实例方法

多态中:
调用子类的实例方法,子类覆盖父类同名实例方法
调用子类静态方法,永远也掉不到
每个方法都有一个常量池

向上转型和向下转型

多态的接地气的理解:父类作为形参,子类类型作为实参。

向上转型:----子类给父类
Pet a =new Dog();
父类 子类
Object aa=a;

向下转型:—先向上,后才能向下,而且不能降到比之前还低。
Dog b=(Dog)a;
Dog e=(Dog)aa;

重写equals
重写比较规则,判断两名学员(Student)是否为同一对象
Student相关属性
Id(学号)、name(姓名)、age(年龄)
如果两名学员的学号以及姓名相同,则为同一对象
先要修改equals方法然后再进行比较。

五、抽象类和接口

1.抽象方法衍生背景

“用进废退”:多态的领域, 父类中被子类重写的实例方法,功能逐渐淡化,索性去掉方法体 退化为抽象方法。

2.抽象方法使用规则

1.抽象方法没有方法体

2.含有抽象方法的类必须是抽象类

3.抽象类中可以暂时没有抽象方法

4.抽象类中的抽象方法跟子类有什么联系?

(1)如果子类完全实现了父类的抽象方法,那么子类可以不用声明为抽象类

(2)如果子类没有完全实现父类的抽象方法,那么子类必须声明为抽象类

3.抽象类的语法规则:

1.被abstract修饰的类是抽象类

2.抽象类中可以有抽象方法,也就是被abstract修饰的方法,也可以没有。

3.抽象方法没有方法体,只有方法声明。

4.子类继承抽象类需要重写父类所有的抽象方法,否则,子类也必须声明为抽象类

5.抽象类有构造方法,但是不能被显示调用,也就是不能实例化,或者说抽象类没有对象。–防止直接调用抽象方法

6.抽象类的构造方法只在子类实例化时隐式调用。

7.抽象类的使用一般是作为引用类型,指向非抽象的引用实例,体现出多态。

8.构造方法和静态方法都不能(abstract)抽象修饰
静态方法不能被子类覆盖(重写),一旦声明为抽象方法 将永远没有具体的实现

4.接口:

定义一个接口:
public interface 接口名{
}

接口的成员:
成员属性:public static final (公共的静态常量)类型
成员方法:public abstract (公共的抽象方法) 或静态方法

接口的应用理解:
接口可以理解为定义的一组通用的组件,或者是对外提供服务的功能模块,具体可替换,可拆卸的特点。接口比抽象类更抽象,已经完全抽象得没边没影。

接口通常作为实体类的成员属性,和实体类是附属关系,而不是包含关系。
为什么接口中的属性是静态的常量?

(1)首先接口由于少了方法的实现,所以不能实例化,这个与抽象类一致,

(2)由于不能实例化,所以对于成员变量只能是static

(3)由于是static所以所有实现了接口的类共享一份

(4)由于所有人共享一份,同时接口的定义是“所有实现该接口的人都共同拥有这些属性/功能”

(5)由于所有的实现类都共同拥有,若是变量则实现类A的改变会导致实现B的改变

(6)会由于实现类的操作而改变的东西违反了接口的定义

(7)所以为了确保每个实现的接口都共同遵守这个“属性”,属性必须是final

(8)由于接口本身的定义是public,最后就是 public static final xxx

(9)若以上说明不够清楚,那就理解为:甲鱼的臀部–龟腚

5.关于default:

1.Jdk8开始,允许接口中有实例方法,但是必须被default修饰

2.出现背景:
对已有的接口,如果想对接口增加一个新方法,那么需要对实现该接口的所有类进行修改,如果接口实的现类很多,就会带来很大的工作量,而且还很容易破坏以前的代码,带来一些问题。如果把新的方法定义为default方法,就可以避免对其他实现类的修改。

3.语法规则
1.实现类不需要重写default修饰的方法 但是也会继承接口中的default方法

2.如果一个类同时实现接口A和B,接口A和B中有相同的default方法,这时,该类必须重写接口中的default方法。为什么要重写呢?是因为,类在继承接口中的default方法时,不知道应该继承哪一个接口中的default方法。

3.如果子类继承父类,父类中有b方法,该子类同时实现的接口中也有b方法(被default修饰),那么子类需要同时重写父类和接口中的b方法。

4.如果一个接口A被标记成函数式接口,那么他所继承的父接口中的抽象方法 必须要用default方法重写,因为函数式接口的规定是:接口中只能有一个抽象方法。接口A中的抽象方法加上继承的父接口中的抽象方法个数之和只能是1

6.总结

1.抽象度:接口>抽象类>类>对象

2.抽象类不能显示调用构造方法,不能直接创建对象,但可以在子类调用构造方法时隐式被调用。

3.接口中只有抽象方法和静态方法,default方法,没有构造方法。

4.接口:提供连接外部组件的口子,理解为一个插口,插槽。所以属性和方法都必须是public

5.抽象类抽掉了对象的概念,接口进一步抽掉了类的概念。

6.接口中的属性没有set/get,也就是不能封装,是static final类型,因为接口已经不再可以理解成类,而是一个组件。组件的属性在出厂时就已经定型了。

7.多态的使用演变:

  1. Fu f=new Zi(); Fu是一个普通类
    2.Fu f=new Zi(); Fu是一个抽象类
    3.Fu f=new Zi(); Fu是一个接口,(使用最多)
  • 0
    点赞
  • 8
    收藏
  • 打赏
    打赏
  • 1
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
©️2022 CSDN 皮肤主题:书香水墨 设计师:CSDN官方博客 返回首页
评论 1

打赏作者

流年丿往昔

你的鼓励将是我创作的最大动力

¥2 ¥4 ¥6 ¥10 ¥20
输入1-500的整数
余额支付 (余额:-- )
扫码支付
扫码支付:¥2
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值