一 Java构造器(构造方法)
java中的构造方法是一种特殊类型的方法,用于初始化对象。Java构造函数在对象创建时被调用。 它构造值,即提供对象的数据,这是为什么它被称为构造函数。
创建java构造函数的规则:
- 构造函数名称必须与其类名称相同
- 构造函数必须没有显式返回类型
有两种类型的构造函数:
1. 默认构造函数(无参数构造函数)
2. 参数化构造函数
1. 默认构造函数(无参数构造函数)
//没有参数的构造函数称为默认构造函数。默认构造函数的语法如下:
<class_name>(){}
//默认构造函数的示例:
class Bike {
Bike() {
System.out.println("Bike is created");
}
public static void main(String args[]) {
Bike b = new Bike();
}
}
//上面的示例代码运行结果如下 -
Bike is created
规则:
1. 如果类中没有构造函数,编译器会自动创建一个默认构造函数。
2. 默认构造函数根据类型为对象提供默认值,如:0,null等。
3. 构造函数返回当前类的实例(不能指定返回值类型,但它会返回一个值)。
2. 构造函数和方法之间的区别
构造函数 | Java方法 |
---|---|
构造器用于初始化对象的状态(数据)。 | 方法用于暴露对象的行为。 |
构造函数不能有返回类型。 | 方法一般都有返回类型。 |
构造函数隐式调用。 | 方法要显式调用。 |
如果没有指定任何构造函数,java编译器提供一个默认构造函数。 | 在任何情况下编译器都不会提供默认的方法调用。 |
构造函数名称必须与类名称相同。 | 方法名称可以或可以不与类名称相同(随意)。 |
二 Java 继承
继承是java面向对象编程技术的一块基石,因为它允许创建分等级层次的类。继承可以理解为一个对象从另一个对象获取属性的过程。
Java中的继承是一种机制,表示为一个对象获取父对象的所有属性和行为。
在Java中继承是:可以创建基于现有类构建新的类。 当您从现有类继承时,就可以重复使用父类的方法和字段,也可以在继承的新类中添加新的方法和字段。
继承表示IS-A关系,也称为父子关系,是说:一个对象是另一个对象的一个分类。
如果类A是类B的父类,而类B是类C的父类,我们也称C是A的子类,类C是从类A继承而来的。在Java中,类的继承是单一继承,也就是说,一个子类只能拥有一个父类
继承中最常使用的两个关键字是extends和implements。
这两个关键字的使用决定了一个对象和另一个对象是否是IS-A(是一个)关系。
通过使用这两个关键字,我们能实现一个对象获取另一个对象的属性。
所有Java的类均是由java.lang.Object类继承而来的,所以Object是所有类的祖先类,而除了Object外,所有类必须有一个父类。
1. 为什么在java中使用继承?
对于方法覆盖(因此可以实现运行时的多态性),提高代码可重用性。在Java中,子类可继承父类中的方法,而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法,而是想作一定的修改,这就需要采用方法的重写(覆盖)。
2. 继承的语法
class Subclass-name extends Superclass-name
{
//methods and fields
}
extends关键字表示正在从现有类派生创建的新类。 “extends”的含义是增加功能。在Java的术语中,继承的类称为父类或超类,新类称为子或子类。
3. java继承类型
3.1. 单一继承示例
class Animal {
void eat() {
System.out.println("eating...");
}
}
class Dog extends Animal {
void bark() {
System.out.println("barking...");
}
}
class TestInheritance {
public static void main(String args[]) {
Dog d = new Dog();
d.bark();
d.eat();
}
}
//执行上面代码得到以下结果
barking...
eating...
3.2 多级继承示例
class Animal {
void eat() {
System.out.println("eating...");
}
}
class Dog extends Animal {
void bark() {
System.out.println("barking...");
}
}
class BabyDog extends Dog {
void weep() {
System.out.println("weeping...");
}
}
class TestInheritance2 {
public static void main(String args[]) {
BabyDog d = new BabyDog();
d.weep();
d.bark();
d.eat();
}
}
//执行上面代码得到以下结果 -
weeping...
barking...
eating...
3.3 多级继承示例
class Animal {
void eat() {
System.out.println("eating...");
}
}
class Dog extends Animal {
void bark() {
System.out.println("barking...");
}
}
class Cat extends Animal {
void meow() {
System.out.println("meowing...");
}
}
class TestInheritance3 {
public static void main(String args[]) {
Cat c = new Cat();
c.meow();
c.eat();
// c.bark();//C.T.Error
}
}
//执行上面代码得到以下结果 -
meowing...
eating...
为什么在Java中不支持多重继承?
为了降低复杂性并简化语言,Java中不支持多重继承。想象一个:A,B和C是三个类。 C类继承A和B类。 如果A和B类有相同的方法,并且从子类对象调用它,A或B类的调用方法会有歧义。
class A {
void msg() {
System.out.println("Hello");
}
}
class B {
void msg() {
System.out.println("Welcome");
}
}
class C extends A,B
{//suppose if it were
Public Static
void main(String args[]) {
C obj = new C();
obj.msg();// Now which msg() method would be invoked?
}
}
编译时错误比运行时错误好,如果继承2个类,java会在编译时报告错误。 所以无论子类中是否有相同的方法,都会有报告编译时错误。例如下面的代码是编译出错的。
三 聚合
如果一个类有一个类的实体引用(类中的类),则它称为聚合。 聚合表示HAS-A关系。
何时使用聚合?
- 当没有is-a关系时,通过聚合也能最好地实现代码重用。
- 只有在所涉及的对象的整个生命周期内维持关系为is-a时,才应使用继承; 否则,聚合是最好的选择。
//Address.java
public class Address {
String city, province;
public Address(String city, String province) {
this.city = city;
this.province = province;
}
}
//Emp.java
public class Emp {
int id;
String name;
Address address;
public Emp(int id, String name, Address address) {
this.id = id;
this.name = name;
this.address = address;
}
void display() {
System.out.println(id + " " + name);
System.out.println(address.city + " " + address.province);
}
public static void main(String[] args) {
Address address1 = new Address("广州", "广东");
Address address2 = new Address("海口", "海南");
Emp e = new Emp(111, "Wang", address1);
Emp e2 = new Emp(112, "Zhang", address2);
e.display();
e2.display();
}
}
//执行上面代码,得到以下结果 -
111 Wang
广州 广东
112 Zhang
海口 海南
四 重写(Override)与重载(Overload)
1.重写
如果子类中具有与父类中声明相同的方法,在java中称为方法覆盖。换句话说,如果子类提供了由其父类提供的其中一个方法的特定实现,则它被称为方法覆盖。所以方法覆盖有两个前提条件:继承和子父类中方法名称相同。
Java方法覆盖的用法
- 方法重写用于提供有别于超类提供的方法的特定实现。
- 方法重写用于运行时多态性。
Java方法覆盖的规则
- 方法必须与父类中的名称相同。
- 方法必须具有与父类中相同的参数。
- 必须是IS-A关系(继承)。
1.1 理解没有方法覆盖的问题
//如果在程序中不使用方法覆盖可能面临的问题。
class Vehicle {
void run() {
System.out.println("Vehicle is running");
}
}
class Bike extends Vehicle {
public static void main(String args[]) {
Bike obj = new Bike();
obj.run();
}
}
//执行上面代码,输出结果如下 -
Vehicle is running
问题是,必须在子类中提供一个run()方法,这就是为什么要使用方法覆盖。
//方法覆盖的示例
//在下面的这个例子中,在父类中和子类中都定义了run方法,但子类中有一些特定的实现。 方法的名称和参数是相同的,并且类之间有IS-A关系,因此这里run方法被覆盖了。
class Vehicle {
void run() {
System.out.println("Vehicle is running");
}
}
class Bike2 extends Vehicle {
void run() {
System.out.println("Bike is running safely");
}
public static void main(String args[]) {
Bike2 obj = new Bike2();
obj.run();
}
}
//执行输出结果如下 -
Bike is running safely
可以覆盖静态方法吗?
这是不可以的,静态方法不能被覆盖。
因为静态方法是绑定类,而实例方法绑定对象。 静态属于类区域,实例属于堆区域。
2. 重载
如果一个类中有多个具有相同名称但参数不同的方法,则称为方法重载。如果只需要执行一个操作,具有相同的方法名称将增加程序的可读性。
假设必须执行给定数值的添加操作(求和),但是参数的数量不固定,如果为两个参数编写add1(int,int)方法,为三个参数编写add2(int,int,int)方法,可能对其他程序员来说很难理解这样的方法的行为,因为它的名称不同。
因此,执行方法重载能比较容易理解程序含义。
方法重载的优点
- 方法重载提高了程序的可读性。
- 重载方法不同的方式
在java中重载方法有两种方式,它们分别是:
- 通过改变参数的数量
- 通过更改数据类型
注意:在java中,只通过更改方法的返回类型来实现方法重载是不可以的。
class Adder {
static int add(int a, int b) {
return a + b;
}
static int add(int a, int b, int c) {
return a + b + c;
}
static double add(double a, double b) {
return a + b;
}
}
class TestOverloading2 {
public static void main(String[] args) {
System.out.println(Adder.add(11, 11));
System.out.println(Adder.add(12.3, 12.6));
}
}
//上面代码执行后,输出结果如下 -
22
24.9
为什么方法重载不能通过更改方法的返回类型?
在java中,只通过改变方法的返回类型来实现方法重载是不可能的,因为这样具有模糊性。 让我们来看看模糊性是怎么样发生的:
class Adder {
static int add(int a, int b) {
return a + b;
}
static double add(int a, int b) {
return a + b;
}
}
class TestOverloading3 {
public static void main(String[] args) {
System.out.println(Adder.add(11, 11));// ambiguity
}
}
//上面代码执行后,输出结果如下 -
Compile Time Error: method add(int,int) is already defined in class Adder
Java
System.out.println(Adder.add(11,11));//这里,java如何确定应该调用哪个sum()方法?
注意:编译时错误优于运行时错误。 所以,如果你声明相同的方法具有相同的参数,java编译器渲染编译器时间错误。
可以重载java main()方法吗?
这是完全可以的。 可以通过方法重载在类中有任意数量的main方法。 但是JVM调用main()方法,它只接收字符串数组作为参数。 让我们来看一个简单的例子:
class TestOverloading4{
public static void main(String[] args){System.out.println("main with String[]");}
public static void main(String args){System.out.println("main with String");}
public static void main(){System.out.println("main without args");}
}
//上面代码执行后,输出结果如下 -
main with String[]
方法重载和方法重写的区别
方法重载 | 方法重写 |
---|---|
方法重载用于提高程序的可读性。 | 方法重写用于提供已经由其超类提供的方法的特定实现。 |
方法重载在类内执行。 | 方法重写发生在具有IS-A(继承)关系的两个类中。 |
在方法重载的情况下,参数必须不同。 | 在方法重写的情况下,参数必须相同。 |
方法重载是编译时多态性的例子。 | 方法重写/覆盖是运行时多态性的例子。 |
方法重载不能仅通过改变方法的返回类型来执行。方法重载中的返回类型可以相同或不同。 但是必须更改参数类型。 | 在方法重写/覆盖中返回类型必须相同或协变。 |
五 多态
多态是同一个行为具有多个不同表现形式或形态的能力。
多态性是对象多种表现形式的体现。
比如我们说"宠物"这个对象,它就有很多不同的表达或实现,比如有小猫、小狗、蜥蜴等等。那么我到宠物店说"请给我一只宠物",服务员给我小猫、小狗或者蜥蜴都可以,我们就说"宠物"这个对象就具备多态性。
//例子
public interface Vegetarian{}
public class Animal{}
public class Deer extends Animal implements Vegetarian{}
因为Deer类具有多重继承,所以它具有多态性。以上实例解析如下:
- 一个 Deer IS-A(是一个) Animal
- 一个 Deer IS-A(是一个) Vegetarian
- 一个 Deer IS-A(是一个) Deer
- 一个 Deer IS-A(是一个)Object
在Java中,所有的对象都具有多态性,因为任何对象都能通过IS-A测试的类型和Object类。
1. 访问一个对象的唯一方法就是通过引用型变量。
2. 引用型变量只能有一种类型,一旦被声明,引用型变量的类型就不能被改变了。
3. 引用型变量不仅能够被重置为其他对象,前提是这些对象没有被声明为final。还可以引用和它类型相同的或者相兼容的对象。它可以声明为类类型或者接口类型。
//当我们将引用型变量应用于Deer对象的引用时,下面的声明是合法的:
Deer d = new Deer();
Animal a = d;
Vegetarian v = d;
Object o = d;
//所有的引用型变量d,a,v,o都指向堆中相同的Deer对象。
虚方法
当子类对象调用重写的方法时,调用的是子类的方法,而不是父类中被重写的方法。
要想调用父类中被重写的方法,则必须使用关键字super。
public class Employee
{
private String name;
private String address;
private int number;
public Employee(String name, String address, int number)
{
System.out.println("Constructing an Employee");
this.name = name;
this.address = address;
this.number = number;
}
public void mailCheck()
{
System.out.println("Mailing a check to " + this.name
+ " " + this.address);
}
public String toString()
{
return name + " " + address + " " + number;
}
public String getName()
{
return name;
}
public String getAddress()
{
return address;
}
public void setAddress(String newAddress)
{
address = newAddress;
}
public int getNumber()
{
return number;
}
}
public class Salary extends Employee
{
private double salary; //Annual salary
public Salary(String name, String address, int number, double
salary)
{
super(name, address, number);
setSalary(salary);
}
public void mailCheck()
{
System.out.println("Within mailCheck of Salary class ");
System.out.println("Mailing check to " + getName()
+ " with salary " + salary);
}
public double getSalary()
{
return salary;
}
public void setSalary(double newSalary)
{
if(newSalary >= 0.0)
{
salary = newSalary;
}
}
public double computePay()
{
System.out.println("Computing salary pay for " + getName());
return salary/52;
}
}
现在我们仔细阅读下面的代码,尝试给出它的输出结果:
public class VirtualDemo
{
public static void main(String [] args)
{
Salary s = new Salary("Mohd Mohtashim", "Ambehta, UP", 3, 3600.00);
Employee e = new Salary("John Adams", "Boston, MA", 2, 2400.00);
System.out.println("Call mailCheck using Salary reference --");
s.mailCheck();
System.out.println("\n Call mailCheck using Employee reference--");
e.mailCheck();
}
}
//以上实例编译运行结果如下:
Constructing an Employee
Constructing an Employee
Call mailCheck using Salary reference --
Within mailCheck of Salary class
Mailing check to Mohd Mohtashim with salary 3600.0
Call mailCheck using Employee reference--
Within mailCheck of Salary class
Mailing check to John Adams with salary 2400.0
例子中,我们实例化了两个Salary对象。一个使用Salary引用s,另一个使用Employee引用。
编译时,编译器检查到mailCheck()方法在Salary类中的声明。
在调用s.mailCheck()时,Java虚拟机(JVM)调用Salary类的mailCheck()方法。
因为e是Employee的引用,所以调用e的mailCheck()方法则有完全不同的结果。
当编译器检查e.mailCheck()方法时,编译器检查到Employee类中的mailCheck()方法。
在编译的时候,编译器使用Employee类中的mailCheck()方法验证该语句, 但是在运行的时候,Java虚拟机(JVM)调用的是Salary类中的mailCheck()方法。
该行为被称为虚拟方法调用,该方法被称为虚拟方法。
Java中所有的方法都能以这种方式表现,借此,重写的方法能在运行时调用,不管编译的时候源代码中引用变量是什么数据类型。
六 抽象类
在面向对象的概念中,所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类。
抽象类除了不能实例化对象之外,类的其它功能依然存在,成员变量、成员方法和构造方法的访问方式和普通类一样。
由于抽象类不能实例化对象,所以抽象类必须被继承,才能被使用。也是因为这个原因,通常在设计阶段决定要不要设计抽象类。
父类包含了子类集合的常见的方法,但是由于父类本身是抽象的,所以不能使用这些方法。
七 封装
在面向对象程式设计方法中,封装(英语:Encapsulation)是指,一种将抽象性函式接口的实作细节部份包装、隐藏起来的方法。
封装可以被认为是一个保护屏障,防止该类的代码和数据被外部类定义的代码随机访问。
要访问该类的代码和数据,必须通过严格的接口控制。
封装最主要的功能在于我们能修改自己的实现代码,而不用修改那些调用我们代码的程序片段。
八 接口
接口(英文:Interface),在JAVA编程语言中是一个抽象类型,是抽象方法的集合,接口通常以interface来声明。一个类通过继承接口的方式,从而来继承接口的抽象方法。
接口并不是类,编写接口的方式和类很相似,但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。
除非实现接口的类是抽象类,否则该类要定义接口中的所有方法。
接口无法被实例化,但是可以被实现。一个实现接口的类,必须实现接口内所描述的所有方法,否则就必须声明为抽象类。另外,在Java中,接口类型可用来声明一个变量,他们可以成为一个空指针,或是被绑定在一个以此接口实现的对象。
接口与类相似点:
- 一个接口可以有多个方法。
- 接口文件保存在.java结尾的文件中,文件名使用接口名。
- 接口的字节码文件保存在.class结尾的文件中。
- 接口相应的字节码文件必须在与包名称相匹配的目录结构中。
接口与类的区别:
- 接口不能用于实例化对象。
- 接口没有构造方法。
- 接口中所有的方法必须是抽象方法。
- 接口不能包含成员变量,除了static和final变量。
- 接口不是被类继承了,而是要被类实现。
- 接口支持多重继承。
8.1 接口的声明
[可见度] interface 接口名称 [extends 其他的类名] {
// 声明变量
// 抽象方法
}
public interface NameOfInterface
{
//任何类型 final, static 字段
//抽象方法
}
接口有以下特性:
- 接口是隐式抽象的,当声明一个接口的时候,不必使用abstract关键字。
- 接口中每一个方法也是隐式抽象的,声明时同样不需要abstract关键子。
- 接口中的方法都是公有的。
8.2 接口的实现
当类实现接口的时候,类要实现接口中所有的方法。否则,类必须声明为抽象的类。
类使用implements关键字实现接口。在类声明中,Implements关键字放在class声明后面。
//实现一个接口的语法,可以使用这个公式:
... implements 接口名称[, 其他接口, 其他接口..., ...] ...
//实例:
public class MammalInt implements Animal{
public void eat(){
System.out.println("Mammal eats");
}
public void travel(){
System.out.println("Mammal travels");
}
public int noOfLegs(){
return 0;
}
public static void main(String args[]){
MammalInt m = new MammalInt();
m.eat();
m.travel();
}
}
//以上实例编译运行结果如下:
Mammal eats
Mammal travels
重写接口中声明的方法时,需要注意以下规则:
- 类在实现接口的方法时,不能抛出强制性异常,只能在接口中,或者继承接口的抽象类中抛出该强制性异常。
- 类在重写方法时要保持一致的方法名,并且应该保持相同或者相兼容的返回值类型。
- 如果实现接口的类是抽象类,那么就没必要实现该接口的方法。
在实现接口的时候,也要注意一些规则:
- 一个类可以同时实现多个接口。
- 一个类只能继承一个类,但是能实现多个接口。
- 一个接口能继承另一个接口,这和类之间的继承比较相似。
8.3 接口的继承
一个接口能继承另一个接口,和类之间的继承方式比较相似。接口的继承使用extends关键字,子接口继承父接口的方法。
在Java中,类的多重继承是不合法,但接口允许多重继承,。
//在接口的多重继承中extends关键字只需要使用一次,在其后跟着继承接口:
public interface Hockey extends Sports, Event
8.4 标记接口
最常用的继承接口是没有包含任何方法的接口。
标识接口是没有任何方法和属性的接口.它仅仅表明它的类属于一个特定的类型,供其他代码来测试允许做一些事情。
标识接口作用:简单形象的说就是给某个对象打个标(盖个戳),使对象拥有某个或某些特权。
//例如:java.awt.event包中的MouseListener接口继承的java.util.EventListener接口定义如下:
package java.util;
public interface EventListener
{}
没有任何方法的接口被称为标记接口。标记接口主要用于以下两种目的:
建立一个公共的父接口:
正如EventListener接口,这是由几十个其他接口扩展的Java API,你可以使用一个标记接口来建立一组接口的父接口。例如:当一个接口继承了EventListener接口,Java虚拟机(JVM)就知道该接口将要被用于一个事件的代理方案。
向一个类添加数据类型:
这种情况是标记接口最初的目的,实现标记接口的类不需要定义任何接口方法(因为标记接口根本就没有方法),但是该类通过多态性变成一个接口类型。