Java类的特性

Java类的特性

一、对象和封装

1、面向对象

面向对象和面向过程的区别

面向对象：面向对象的核心是封装了属性和方法的类，以数据为中心，实现了类级别的代码重用；面向对象因为采用了类，所以具有继承和多态的特性，可以进一步重用代码和简化编程。（面向对象就像是自己组装电脑）

面向过程：面向过程的核心是函数，以功能为中心，实现了函数级别的代码重用；面向过程没有继承和多态特性。（面向过程就像是自己造电脑，每一个零件都要自己造出来）

面向对象的设计步骤：

1、发现类

2、发现类的属性

3、发现类的方法

原则：

1、属性和方法的设置是为了解决业务问题

2、关注主要的属性和方法

3、如果没有必要，勿增加额外的类、属性和方法。

2、创建类和对象

类和对象是面向对象的两个核心概念；类是对某一类事物的描述，是抽象的概念上的定义，对象是实际存在的，具体的事物个体。

3、构造函数及重载

1）、构造函数（Constructor）

Java中的构造函数和C#中的构造函数是一样的；

作用：new对象，兼职给成员变量赋值

语法：访问修饰符 类名（形参列表）{ }

分类：

1、参数：有参（小括号里带参数的是有参构造函数）、无参（小括号里没有参数的是无参构造函数）

2、显示方式：隐式（在没有手写构造函数的情况下，系统会给一个默认的无参构造函数）、显示（手写构造函数）

2）、重载

重载的特点：

1、方法名相同，在同一个类，参数不同（参数个数的不同或数据类型的不同）

4、关键字

1、final

final是常量的意思，可以修饰类、方法、变量；

final修饰变量：只能初始化一次

final String str = "嘤嘤嘤";

final修饰方法：不能被子类重写，但是可以重载

//被final修饰的方法不能被子类重写
public final void show(){
    System.out.printle("嘤嘤嘤");
}

final修饰类：不能被继承

//被final修饰的类是不能被继承的
public final class Peint{
	//主体
}

2、static

static是静态的意思，静态成员属于类；

static区别于C#和Java：

C#：C#中static成员只能用类名去点

Java：建议用类名去点，也可以用对象名去点（不建议用对象名点）；

方法：属于类，通过类名或对象名去点

静态块：在生成class文件时就被执行了

静态块的语法：static{}

static修饰类：static修饰的类必须是内部类

public class A{
	public static class B{
		//主体
	}
}

3、this

this是当前类的对象的引用

4、super

super调用父类的，类似C#的base的作用

5、访问修饰符

Java中的访问修饰符有四个：public 、protect、friendly（Java中的默认访问修饰符）、private

访问的范围（在继承关系中）：

public：所有类都可以访问

protected：本类和子类（同包/不同包）可以访问

friendly：本类和同包子类可以访问

private：本类

二、继承

1、定义

继承的定义：子承父，描述两个类之间的关系

2、子父类之间的关系

1、子类能拥有父类的非private的行为

2、构造函数
1】注意，在子类调用父类的构造函数时super和this只能位于第一行
2】子父类关系
1、先调用父类的构造函数，再调用子类的构造函数

2、默认情况下，子类会调用父类的无参构造函数

3】子类怎么调用父类的构造函数

a、语法：在子类的构造函数里面写super(参数列表)

b、在构造函数中写this()，这是调用本类的无参构造函数；this(参数)，是调用本类的有参构造函数

c、在一个构造函数中this和super只能调用其中的一个

3、访问修饰符

访问修饰符	本类	子类（不同包）	子类（同包）	其他位置
private	true	false	false	false
friendly	true	false	true	false
protected	true	true	true	false
public	true	true	true	true

前提：要有继承关系

访问注意：

1、在通过对象名去访问，在不同包中只有public可以访问到，但是在同胞中只有private访问不到

2、使用范围（从大到小）：public ---->protected---->friendly---->private

3、语法

继承的语法：子类 extends 父类

4、特性

1、单根性：只能有一个父类

2、传递性：孙能拥有父类的行为

注：默认父类是：Object

5、重写

1、重写

1、定义

实现多态的手段之一

2、前提

一定有继承关系，至少两个类

3、特点

1、方法名相同，在不同类中，参数相同

2、访问修饰符： 父类的访问级别 <= 子类的访问级别（子类不能缩小访问修饰符）

3、返回值： 父类的返回值 >= 子类的返回值（父类的返回值包含子类的返回值）

4、抛出异常： 父类的异常级别 >= 子类的异常级别

2、实现重写

1、区别Java和C#：

1、如果C#中要表明是重写一定要显示定义：virtual，abstract

2、Java中实现重写：方法名相同，参数相同

2、重写

1、直接重写 —>相同的方法名，相同参数

2、注解可以写也可以省略：@Override

3、抽象方法：abstract

a、特点

1、没有方法体

2、必须在抽象类中

3、子类必须重写抽象方法，除非子类也是抽象类

b、抽象类

1、抽象类中可以有非抽象方法

2、抽象类不能实例化

6、注解和内部类

注解：注解以@开头，有兴趣的可以自行上网搜索

内部类：

1、内部类：内部类就是在一个类中再定义一个类

2、内部类的作用：内部类可以很好的实现隐藏；内部类拥有外围类的所有元素的访问权限；可以实现多重继承；可以避免修改健康而实现同一个类中两种同名方法的调用。

三、多态

1、多态

1、定义：一个事物的多种形态

2、实现方式：重写和重载

3、重载：在同一个类中实现多态

重载的特点：在同一个类中，方法名相同，参数不同（参数类型或参数个数）

2、重写

在不同类中实现多态

1、前提：至少两个类，要有继承关系

2、相同的方法名，相同的参数，在不同的类中

3、访问修饰符： 父类的访问级别 <= 子类的访问级别（子类不能缩小访问修饰符）

返回值： 父类的返回值 >= 子类的返回值（父类的返回值包含子类的返回值）

抛出异常： 父类的异常级别 >= 子类的异常级别

4、实现方式：

a、普通重写：子类不一定要实现父类的方法 —>没有强制要求

b、抽象方法

1、没有方法体

2、必须在抽象类中

3、子类必须重写抽象方法，除非子类也是抽象类

c、抽象类

1、抽象类中可以有非抽象方法

2、抽象类不能实例化

3、数据类型

1、区别C#和Java

1、C#中：is：判断数据类型，as：强制转化

2、Java中：

1、instanceof：判断数据类型；

语法：对象 instanceof 接口/类

2、Java中类/对象三种关系

is a ：继承关系-----> 继承

has a：包含关系---->属性

like a：像/依赖关系----->接口

2、转型

1、向上转型：子类到父类

//Father是父类，Stu是子类
Father father = new Stu();

2、向下转型：父类到子类

//Father是父类，Stu是子类
Stu stu = (Stu)father;

3、数据类型

Java的数据类型分为：基本数据类型和引用数据类型两种，之前的文章介绍过了，这里就不在过多介绍了。

每一个基本数据类型都有一个对应得引用数据类型

基本数据类型	对应的引用数据类型
int	Integer
char	Character
long	Long
float	Float

这里就不介绍完了，除了int类型和char类型是不同的之外，其他的基本数据类型对应的引用数据类型都是将首字母大写就可以了。

注意：

//这是隐式转换
int i = 1;
double j = i;

//值的包装
int i = 1;
Integer m = i;

//Long 和 Integer是兄弟关系
Integer m = 1;
Long l = m;

四、接口

1、接口的定义

1、语法： 关键字：interface； public interface 接口名{}

2、特点：

a、不能实例化（就是不能new）；

b、方法都是抽象方法（abstract），默认访问修饰符：public abstract

3、抽象方法的作用：为了规定子类重写

4、接口的作用：约束子类必须拥有某种行为（或功能）

5、区别继承和接口

继承：单继承：一个类有且只能有一个父类

接口：多实现：一个类可以实现多个接口

注：一个类绝对只能有一个父类，但是可以被约束具有多种行为

2、接口的继承

1、语法：关键字：implements；

子类 implements 接口1，接口2……（没有继承关系父类的）

子类 extends 父类 implements 接口1，接口2……（有继承关系的）

顺序：有继承父类的，父类必须在接口前面

3、接口的注意点和抽象类的区别

1、成员变量：只能定义静态常量

默认访问修饰符：public static final

2、构造函数：不能有构造函数

3、接口和抽象类的区别

相同点：

1、都不能实例化

2、约束子类必须重写抽象方法，除非子类也是抽象类或是接口

不同点：

1、关键字不同：abstract（抽象类），interface（接口）

2、接口只能有抽象方法，抽象类可以有非抽象方法

3、接口不能有构造函数，抽象类可以有

4、成员变量：抽象类可以有非静态的，可以不是常量；接口只能有（static final）静态常量

4、命名规则：接口以大写字母“I”开头

4、原则

1、依赖倒置原则

依赖倒置原则：细节依赖于抽象，高层模块和底层模块都应该依赖于抽象

举例1：建房子：（细节）

第一天：张三画图；第二天：李四建造； 第三天：王五粉刷； 第四天：二哈装饰；如果第二天的李四生病了，来不了了，那么后面的工序就无法完成，因为张三，李四这些都是具体的对象。

举例2：建房子：（抽象）

第一天：发布一个招聘画图的公告；第二天：发布一个招聘建造的公告； 第三天：发布一个招聘粉刷的公告； 第四天：发布一个装饰画图的公告；这样李四生不生病了，来不来都没关系，只要是有这个能力的都可以来工作，就不会出现后面的工序完成不了，这些就是类、接口了，这些就是抽象的，不再是具体的对象了。

高层模块和底层模块都应该依赖于抽象：

Connection（连接数据库的关键字）----->SqlConnection (Sql server数据库的连接)

Connection（连接数据库的关键字）----->MySqlConnection (MySql server数据库的连接)

Java分层写代码：数据库访问层-----业务逻辑层----表现层

依赖于一个概念，而不是具体存在的对象。

2、接口隔离原则

接口隔离原则：一个类对另一个类的依赖应该建立在最小的接口与单一职责类似

单一职责：要求的是类

接口隔离原则：要求的是接口

3、开闭原则

开闭原则：对修改关闭，对扩展开放

就是对新增功能尽量不要去修改原来的代码

5、C#接口的实现

1、C#接口的实现流程和Java的没区别：关键字：interface

2、定义：

子类：父类，接口1，接口2……（有继承关系的，继承父类在前，接口在后）

子类：接口1，接口2……（没有继承关系的，就直接继承接口就可以了）

3、接口里面不能有字段（就是不能定义字段）

4、属性的默认修饰符：public static const，但是不能显示定义（就是不能写修饰）

5、方法的默认修饰符：public abstract，也不能显示定义

6、不能实例化对象，不能有构造函数。