公司的宣传网站应该怎么做,上海市企业服务云官网,j2ee网站开发参考文献,做市级网站需要什么意思目录
前言
一、抽象类
1.1什么是抽象类
1.2抽象类代码实现
1.3 抽象类特点
1.4抽象类的作用
二、接口
2.1什么是接口
2.2接口的代码书写
2.3 接口使用
2.4 接口特点
2.5 实现多个接口
快捷键#xff08;ctrl i #xff09;#xff1a;
2.6接口的好处
2.7 接…目录
前言
一、抽象类
1.1什么是抽象类
1.2抽象类代码实现
1.3 抽象类特点
1.4抽象类的作用
二、接口
2.1什么是接口
2.2接口的代码书写
2.3 接口使用
2.4 接口特点
2.5 实现多个接口
快捷键ctrl i
2.6接口的好处
2.7 接口间的继承 2.8 接口使用实例
实例一
Comparable 接口给对象排序
2.9Clonable 接口和深拷贝
2.10 抽象类和接口的区别常见面试题
三、Object类
使用示范
3.1Object类中toString()方法
3.2Object类中equals()方法
3.3Object类中hashcode()方法 前言 本篇博客主要讲解Java基础语法中的 抽象类和接口、抽象类和接口的概念、代码书写、特点、作用。实现多个接口快捷键ctrl i 的使用、Comparable接口给对象排序、Clonable接口和深拷贝、抽象类和接口的区别、Object类、Object类中的toString()方法equals()方法hashcode()方法 大家好本人是普通一本的在校大学生一枚目前在学习java。之前也学了一段时间但是没有发布博客。本人现在已经大二结束了开学就大三了时间过的真的很快。我会利用好这个暑假来复习之前学过的内容并整理好之前写过的博客进行发布。如果博客中有错误或者没有读懂的地方。热烈欢迎大家在评论区进行讨论 喜欢我文章的兄弟姐妹们可以点赞收藏和评论我的文章。喜欢我的兄弟姐妹们以及也想复习一遍java知识的兄弟姐妹们可以关注我呦我会持续更新滴并且追求完整。 望支持一起加油呀 语言只是工具不能决定你好不好找工作决定你好不好找工作的是你的能力
学历本科及以上就够用了 一、抽象类
1.1什么是抽象类 如果 一个类中没有包含足够的信息来描绘一个具体的对象这样的类就是抽象类。 我们知道所有的对象都是通过一个类来描述的。
但是并不是所有类都是用来描述对象的。
比如之前我们在面向对象系列中所提到的矩形、圆、花。他们都是图形。因此他们可以继承Shape类。而在Shape类中我们有draw方法。但是由于Shape类不是具体的图形。因此不会用到draw方法。而是矩形、圆、花它们用draw方法。因此draw方法其实在Shape类中无法具体实现。所以我们可以将Shape类设计成一个“抽象类”。而把其中的draw方法我们设计成“抽象方法”。
1.2抽象类代码实现
如果一个类被abstract修饰那么我们称之为这是一个抽象类。
如果一个方法被abstract修饰。那么我们称之为这是一个抽象方法。抽象方法不用给出具体实现。因为实际上它是要被子类重写。从而调用子类重写的方法。通过子类实现。
// 抽象类被abstract修饰的类
public abstract class Shape {// 抽象方法被abstract修饰的方法没有方法体abstract public void draw();abstract void calcArea();// 抽象类也是类也可以增加普通方法和属性public double getArea(){return area;}protected double area; // 面积
} 如上代码。我们将Shape设计成抽象类。将draw设计成抽象方法。抽象类也可以有普通成员变量和普通成员方法。 甚至构造方法 1.3 抽象类特点
1. 抽象类不能直接实例化对象。
2. 抽象方法不能是 private 修饰的
3. 抽象方法不能被final和static修饰因为抽象方法要被子类重写
4.抽象类必须被继承。并且继承后子类需要重写父类中的抽象方法。否则子类也是抽象类。必须用abstract修饰。
5.抽象类中不一定包含抽象方法。但是有抽象方法的类一定是抽象类。
6.抽象类中可以有构造方法。让子类创建对象时可以初始化父类成员变量。
1.4抽象类的作用
我们可以使用普通类被继承。但是使用普通类继承可以在编写代码时出现很多错误。比如我们不小心在子类中调用了父类需要被子类重写的方法。而使用抽象类。父类不能被实例化。因此也就无法调用其方法。因此使用抽象类可以预防出错。 二、接口
2.1什么是接口
在现实生活中接口的例子比比皆是比如笔记本上的USB口电源插座等。 接口就是公共的行为规范标准大家在实现时只要符合规范标准就可以通用。 在Java中接口可以看成是多个类的公共规范是一种引用数据类型。 2.2接口的代码书写
我们使用 interface 关键字来定义了一个接口。它与类的定义相似。我们把class关键字换成interface。那么它就从一个类变成一个接口了。
public interface 接口名称{// 抽象方法public abstract void method1(); // public abstract 是固定搭配可以不写public void method2();abstract void method3();void method4();// 注意在接口中上述写法都是抽象方法跟推荐方式4代码更简洁
}注
1.创建接口时接口命名一般以大写字母 I 开头。
2.接口命名一般使用形容词的单词。
3.在规范中接口中的方法和属性不加任何修饰符。保证代码的简洁。
2.3 接口使用
接口不能被直接使用。而是需要一个“实现类”来实现接口中的所有抽象方法。
如 extends 关键字一样。我们使用 implements 关键字来实现接口
public class 类名称 implements 接口名称{// ...
} 注意子类和父类之间是extends 继承关系类与接口之间是 implements 实现关系。 代码示例
请实现笔记本电脑使用USB鼠标、USB键盘的例子
1. USB接口包含打开设备、关闭设备功能
2. 笔记本类包含开机功能、关机功能、使用USB设备功能
3. 鼠标类实现USB接口并具备点击功能
4. 键盘类实现USB接口并具备输入功能
//USB接口
public interface USB{void openDevice();void closeDevice();
}//鼠标类实现USB接口。
public class Mouse implements USB{Overridepublic openDevice(){Ststem.out.println(打开鼠标);}Overridepublic closeDevice(){Ststem.out.println(关闭鼠标);}public void click(){System.out.println(鼠标点击);}
}// 键盘类实现USB接口
public class KeyBoard implements USB {Overridepublic void openDevice() {System.out.println(打开键盘);}Overridepublic void closeDevice() {System.out.println(关闭键盘);}public void inPut(){System.out.println(键盘输入);}
}// 笔记本类使用USB设备
public class Computer {public void powerOn(){System.out.println(打开笔记本电脑);}public void powerOff(){System.out.println(关闭笔记本电脑);}public void useDevice(USB usb){usb.openDevice();if(usb instanceof Mouse){Mouse mouse (Mouse)usb;mouse.click();}else if(usb instanceof KeyBoard){KeyBoard keyBoard (KeyBoard)usb;keyBoard.inPut();}usb.closeDevice();}
}// 测试类
public class TestUSB {public static void main(String[] args) {Computer computer new Computer();computer.powerOn();// 使用鼠标设备computer.useDevice(new Mouse());// 使用键盘设备computer.useDevice(new KeyBoard());computer.powerOff();}
}
2.4 接口特点
1. 接口类型是一种引用类型但是不能直接new接口的对象
2.接口中的方法都是public abstract修饰的被隐式的指定。其他修饰符都会报错
3. 接口中的方法不能在接口中实现只能由实现接口的类来实现。
4. 重写接口中方法时不能使用默认的访问权限。
5. 接口中的变量会被隐式的指定为 public static final 变量。可以直接通过接口名访问
6. 接口中不能有静态代码块和构造方法
7. 接口虽然不是类但是接口编译完成后字节码文件的后缀格式也是.class
8. 如果类没有实现接口中的所有的抽象方法则类必须设置为抽象类
9. jdk8中接口中还可以包含default方法。
2.5 实现多个接口 一个类是可以实现多个接口。 区别于 Java中类和类之间是单继承的一个类只能有一个父类即Java中不支持多继承 注意一个类实现多个接口时每个接口中的抽象方法都要实现否则类必须设置为抽象类。
快捷键ctrl i IDEA 中使用 ctrl i 快速实现接口。 2.6接口的好处
class Duck extends Animal implements IRunning, ISwimming, IFlying {public Duck(String name) {super(name);}Overridepublic void fly() {System.out.println(this.name 正在用翅膀飞);}Overridepublic void run() {System.out.println(this.name 正在用两条腿跑);}Overridepublic void swim() {System.out.println(this.name 正在漂在水上);}
} 上面的代码展示了 Java 面向对象编程中最常见的用法:
一个类继承一个父类, 同时实现多种接口. 继承表达的含义是 is - a 语义,接口表达的含义是 具有 xxx 特性 . 猫是一种动物, 具有会跑的特性. 青蛙也是一种动物, 既能跑, 也能游泳 鸭子也是一种动物, 既能跑, 也能游, 还能飞 这样的设计。时刻牢记多态的好处, 让程序猿忘记类型. 有了接口之后, 类的使用者就不必关注具体类型, 而只关注某个类是否具备某种能力. 2.7 接口间的继承
类和类之间是单继承的一个类可以实现多个接口 接口与接口之间可以多继承。即用接口可以达到 多继承的目的 使用 extends 关键字. interface IRunning {void run();
}interface ISwimming {void swim();
}// 两栖的动物, 既能跑, 也能游
interface IAmphibious extends IRunning, ISwimming {}class Frog implements IAmphibious {...
}通过接口继承创建一个新的接口 IAmphibious 表示 两栖的. 此时实现接口创建的 Frog 类, 就继续要实现 run 方 法, 也需要实现 swim 方法. 接口间的继承相当于把多个接口合并在一起. 2.8 接口使用实例
实例一 给对象数组排序 class Student {private String name;private int score;public Student(String name, int score) {this.name name;this.score score;}Overridepublic String toString() {return [ this.name : this.score ];}
} 再给定一个学生对象数组, 对这个对象数组中的元素进行排序(按分数降序). Student[] students new Student[] {new Student(张三, 95),new Student(李四, 96),new Student(王五, 97),new Student(赵六, 92),
};按照我们之前的理解, 数组我们有一个现成的 sort 方法, 能否直接使用这个方法呢? 是不可以的。 Arrays.sort(students);
System.out.println(Arrays.toString(students));// 运行出错, 抛出异常.
Exception in thread main java.lang.ClassCastException: Student cannot be cast to java.lang.Comparable 和普通的整数不一样, 两个整数是可以直接比较的, 大小关系明确. 而两个学生对象的大小关系 怎么确定? 需要我们额外指定 让我们的 Student 类实现
Comparable 接口给对象排序
并实现其中的 compareTo 方法
class Student implements Comparable {private String name;private int score;public Student(String name, int score) {this.name name;this.score score;}Overridepublic String toString() {return [ this.name : this.score ];}Overridepublic int compareTo(Object o) {Student s (Student)o;if (this.score s.score) {return -1;} else if (this.score s.score) {return 1;} else {return 0;}}
}
class Main{public static void main(String[] args) {Student[] students new Student[] {new Student(张三, 95),new Student(李四, 96),new Student(王五, 97),new Student(赵六, 92),};Arrays.sort(students);System.out.println(Arrays.toString(students));}
}
执行结果
// 执行结果
[[王五:97], [李四:96], [张三:95], [赵六:92]] 在 sort 方法中会自动调用 compareTo 方法. compareTo 的参数是 Object , 其实传入的就是 Student 类型的对象. 然后比较当前对象和参数对象的大小关系(按分数来算). 如果当前对象应排在参数对象之前, 返回小于 0 的数字;如果当前对象应排在参数对象之后, 返回大于 0 的数字;如果当前对象和参数对象不分先后, 返回 0;
再次执行程序, 结果就符合预期了. 注意事项: 对于 sort 方法来说, 需要传入的数组的每个对象都是 可比较 的, 需要具备 compareTo 这样的能力. 通过重写 compareTo 方法的方式, 就可以定义比较规则. 我们可以尝试自己实现一个 sort 方法来完成刚才的排序过程(使用冒泡排序)
public static void sort(Comparable[] array) {for (int bound 0; bound array.length; bound) {for (int cur array.length - 1; cur bound; cur--) {if (array[cur - 1].compareTo(array[cur]) 0) {// 说明顺序不符合要求, 交换两个变量的位置Comparable tmp array[cur - 1];array[cur - 1] array[cur];array[cur] tmp;}}}
} 再次执行代码 sort(students);
System.out.println(Arrays.toString(students));// 执行结果
[[王五:97], [李四:96], [张三:95], [赵六:92]]
2.9Clonable 接口和深拷贝
Java 中内置了一些很有用的接口, Clonable 就是其中之一.
Object 类中存在一个 clone 方法, 调用这个方法可以创建一个对象的 拷贝. 但是要想合法调用 clone 方法, 必须要 先实现 Clonable 接口, 否则就会抛出 CloneNotSupportedException 异常.
我们点进去Clonable接口会发现 这是一个空接口这也叫做标记接口证明当前类是可以被克隆的 class Animal implements Cloneable {private String name;Overridepublic Animal clone() {Animal o null;try {o (Animal)super.clone();} catch (CloneNotSupportedException e) {e.printStackTrace();}return o;}
}public class Test {public static void main(String[] args) {Animal animal new Animal();Animal animal2 animal.clone();System.out.println(animal animal2);}
}// 输出结果
// false浅拷贝 VS 深拷贝 Cloneable 拷贝出的对象是一份 浅拷贝 观察以下代码: class Money {public double m 99.99;
}class Person implements Cloneable{public Money money new Money();Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();}
}public class TestDemo3 {public static void main(String[] args) throws CloneNotSupportedException {Person person1 new Person();Person person2 (Person) person.clone();System.out.println(通过person2修改前的结果);System.out.println(person1.money.m);System.out.println(person2.money.m);person2.money.m 13.6;System.out.println(通过person2修改后的结果);System.out.println(person1.money.m);System.out.println(person2.money.m);}
}
// 执行结果
通过person2修改前的结果
99.99
99.99
通过person2修改后的结果
13.6
13.6如上图我们克隆的只是person这个对象。并没有克隆对象里面的对象。克隆之后。Money m中的引用还是指向0x65。
因此我们修改person2中的money数值为13.6后person1中的money数值也发生了改变。
这个就叫做浅拷贝。
而深拷贝就是还会克隆对象里面的对象。修改person2中的money数值为13.6后person1中的money数值不变改变。 通过clone我们只是拷贝了Person对象。 但是Person对象中的Money对象并 没有拷贝。 通过person2这个引用修改了m的值后person1这个引用访问m的时候值也发生了改变。 这里就是发生了浅拷贝。那么想一下如何实现深拷贝呢 实现深拷贝。需要我们自己重写clone方法。如下
class Money {public double m 99.99;
}class Person implements Cloneable{public Money money new Money();Overrideprotected Object clone() throws CloneNotSupportedException {Person temp (person)super.clone();tem.m (Money)this.m.clonereturn temp;}
}public class TestDemo3 {public static void main(String[] args) throws CloneNotSupportedException {Person person1 new Person();Person person2 (Person) person.clone();System.out.println(通过person2修改前的结果);System.out.println(person1.money.m);System.out.println(person2.money.m);person2.money.m 13.6;System.out.println(通过person2修改后的结果);System.out.println(person1.money.m);System.out.println(person2.money.m);}
}
// 执行结果
通过person2修改前的结果
99.99
99.99
通过person2修改后的结果
99.99
13.6此时就实现了深拷贝 2.10 抽象类和接口的区别常见面试题 抽象类和接口都是 Java 中多态的常见使用方式. 都需要重点掌握. 同时又要认清两者的区别 核心区别: 抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写), 而 接口中 不能包含普通方法,和普通变量。 子类必须重写所有的抽象方法. 如之前写的 Animal 例子. 此处的 Animal 中包含一个 name 这样的属性, 这个属性在任何子类中都是存在的. 因此此 处的 Animal 只能作为一个抽象类, 而不应该成为一个接口.
class Animal {protected String name;public Animal(String name) {this.name name;}
}
再次提醒: 抽象类存在的意义是为了让编译器更好的校验, 像 Animal 这样的类我们并不会直接使用, 而是使用它的子类. 万一不小心创建了 Animal 的实例, 编译器会及时提醒我们. 三、Object类 Object是Java默认提供的一个类。 Java里面除了Object类所有的类都是存在继承关系的。 java中所有类默认会继承Object父类。 因此所有类的对象都可以使用Object的引用进行接收。 使用示范
class Person{}
class Student{}
public class Test {public static void main(String[] args) {function(new Person());function(new Student());}public static void function(Object obj) {System.out.println(obj);}
}
//执行结果
Person1b6d3586
Student4554617c 在开发之中 Object类是参数的最高统一类型。但是Object类也存在有定义好的一些方法。如下 对于整个Object类中的方法需要实现全部掌握。
下面我们主要来熟悉这几个方法toString()方法equals()方法hashcode()方法
3.1Object类中toString()方法 获取对象信息 如果要打印对象中的内容可以直接重写Object类中的toString()方法之前已经讲过了 // Object类中的toString()方法实现
public String toString() {return getClass().getName() Integer.toHexString(hashCode());
}3.2Object类中equals()方法 在Java中进行比较时 a.如果左右两侧是基本类型变量比较的是变量中值是否相同 b.如果左右两侧是引用类型变量比较的是引用变量地址是否相同 c.如果要比较对象中内容必须重写Object中的equals方法因为equals方法默认也是按照地址比较的 // Object类中的equals方法
public boolean equals(Object obj) {return (this obj); // 使用引用中的地址直接来进行比较
}
class Person{private String name ; private int age ; public Person(String name, int age) {this.age age ; this.name name ;}
}
public class Test {public static void main(String[] args) {Person p1 new Person(gaobo, 20) ; Person p2 new Person(gaobo, 20) ; int a 10;int b 10;System.out.println(a b); // 输出trueSystem.out.println(p1 p2); // 输出falseSystem.out.println(p1.equals(p2)); // 输出false}
}
Person类重写equals方法后然后比较
class Person{...Overridepublic boolean equals(Object obj) {if (obj null) {return false ; }if(this obj) {return true ; }// 不是Person类对象if (!(obj instanceof Person)) {return false ; }Person person (Person) obj ; // 向下转型比较属性值return this.name.equals(person.name) this.ageperson.age ; }
} 结论比较对象中内容是否相同的时候一定要重写equals方法。 3.3Object类中hashcode()方法
回忆刚刚的toString方法的源码
public String toString() {return getClass().getName() Integer.toHexString(hashCode());
} hashCode()这个方法他帮我算了一个具体的对象位置我们只能说它是个内存地址但不是真的地址。然后调用Integer.toHexString()方法将这个地址以16进制输出。 hashcode方法源码
public native int hashCode();
该方法是一个native方法底层是由C/C代码写的。我们看不到。
我们认为两个名字相同年龄相同的对象将存储在同一个位置如果不重写hashcode()方法我们可以来看
示例 代码
class Person {public String name;public int age;public Person(String name, int age) {this.name name;this.age age;}
}
public class TestDemo4 {public static void main(String[] args) {Person per1 new Person(gaobo, 20) ;Person per2 new Person(gaobo, 20) ;System.out.println(per1.hashCode());System.out.println(per2.hashCode());}
}
//执行结果
460141958
1163157884注意事项 两个对象的hash值不一样。 像重写equals方法一样我们也可以重写hashcode()方法。此时我们再来看看。 class Person {public String name;public int age;public Person(String name, int age) {this.name name;this.age age;}Overridepublic int hashCode() {return Objects.hash(name, age);}
}
public class TestDemo4 {public static void main(String[] args) {Person per1 new Person(gaobo, 20) ;Person per2 new Person(gaobo, 20) ;System.out.println(per1.hashCode());System.out.println(per2.hashCode());}
}
//执行结果
460141958
460141958 注意事项哈希值一样。 结论
1、hashcode方法用来确定对象在内存中存储的位置是否相同
2、事实上hashCode() 在散列表中才有用在其它情况下没用。在散列表中hashCode() 的作用是获取对象的 散列码进而确定该对象在散列表中的位置。
