标签：26 return 07 接口 superLinked 抽象 2022 抽象类 public
JAVA面向对象(抽象，接口)
今日重点
- 抽象
- abstract
- 抽象方法
- 接口
- 匿名实现类
- 栈
- 队列
学习心得
今日学习了抽象和接口，里面或多或少都涉及了一些多态，可能会搞混，需要进一步巩固，接口也可以看做完全抽象，里面的方法是没有方法体的，需要在实现类里面全部重写接口里的方法。栈和队列属于数据结构了，可以用提前写好的超级数组当方法去实现栈和队列，栈是先进后出，队列是先进先出。
抽象
Java中，除了类，还有抽象类和接口
抽象方法必须在一个抽象类里
1.当我们定义一个抽象类，这个抽象类中可以有哪些结构？
属性，成员方法，构造器，抽象方法，常量
2.抽象类中能不能没有抽象方法？
抽象类可以没有抽象方法
3.抽象类是不能被实例化的。
抽象类不能创建对象。
4.抽象类的构造器存在的意义
为了约定子类的构造器必须和父类要匹配
5.一个类如果继承了一个抽象类，就必须重写这个抽象类所有的抽象方法
abstract能修饰什么？
类，方法
抽象方法能不能用private修饰？不能。开发中，抽象方法基本上都是public
抽象方法能不能用final修饰？不能。用final修饰的方法是不允许重写。
抽象类能不能用final修饰？不能。用final修饰的类是不允许被继承的。
总结一下：
- 抽象方法必须是public或者protected（因为如果是private，不能被子类继承，子类便无法实现该方法），默认情况下是可以的。（默认情况其实就是public）
- 子类便无法实现该方法），默认情况下是可以的。（默认情况其实就是public）
- 抽象类必须有子类，使用extends继承，一个类只能继承一个抽象类。
- 子类（如果不是抽象类）则必须重写抽象类中的所有抽象方法)（如果子类没有实现父类的抽象方法，必须将子类也定义为abstract）
抽象方法
抽象方法，没有大括号，没有方法体。
抽象方法，存在的意义是什么？
根本意义，约定。自定义的规则。
抽象方法到底约定了什么，规定了什么，定了哪些规则？
约定了返回值，访问权限，参数列表，需要在重写的时候去定义方法体
约定大于配置，配置大于编码
静态常量
public static final String NAME = "张三";
抽象方法
public abstract void breath();
静态方法
public static void show(){
}
接口
比抽象类更高级的抽象
声明：
使用interface关键字，public interface Ch02
JDK1.7之前：接口中只能定义抽象方法，不能有属性，不能有方法。（静态的常量）
JDK8及以后：接口中只能定义抽象方法，不能有属性，可以有默认方法和静态方法(静态常量).
JDK7---JDK8：默认方法，静态方法。
接口中结构的特点：
接口中的抽象方法默认是public abstract，我们推荐就省略了。
接口中的常量默认是public static final，我们推荐就省略了。
说一句话：接口中的结构必须是public。
接口可以被实现，实现类
比如说A类 implements 接口，那我们就说A是这个接口的实现类。
如果一个类实现了一个接口，它就需要重写接口中所有的抽象方法。
实现接口是可以多实现的，继承只能单继承。
开发中，如果一件事情可以通过继承和实现接口来解决问题，接口解决。
面试题
- 继承抽象类和实现接口的异同。
- 抽象类和接口的区别。
接口存在的意义？
约定
多态的前提条件？
1.继承，实现
2.重写方法
3.父类---子类，接口---实现类
面试题：在java中只有单继承？
在java中是存在多继承的，发生在接口之间。
java类与类之间只有单继承。
抽象类也是比类更高级的抽象。
public class Ch02 {
public static void main(String[] args) {
// 向上转型---继承
Animal animal = new Cat();
// 向上转型---实现
Biology biology = new Cat();
}
}
这个Cat类就继承了Animal类同时实现了Biology接口，Cat类就可以叫做Animal类的子类，也可以叫做Biology类的实现类
public class Cat extends Animal implements Biology,CatsAnimal{}
有关接口的案例
package com.morning.test;
/**
* 图形类：
*
* 可以有几个属性：
* 边长，角度，高
*
* 创建子类：
* 正方形，长方形，三角形，圆柱体，圆锥体，梯形.....
*
*/
public abstract class Graphics {
public abstract Double area(Double ... args);
public abstract Double volume();
public abstract Double perimeter();
}
---
package com.morning.test;
public class Circle extends Graphics {
/**
* 只能传入一个参数，即为圆的半径
* @param args
* @return
*/
@Override
public Double area(Double ... args) {
if(args.length > 1){
throw new RuntimeException("只能传入一个参数");
}
return 3.14 * args[0] * args[0];
}
@Override
public Double volume() {
return null;
}
@Override
public Double perimeter() {
return null;
}
}
---
package com.morning.test;
public class Trapezoid extends Graphics {
@Override
public Double area(Double ... args) {
return ((args[0] + args[1]) * args[2]) / 2 ;
}
@Override
public Double volume() {
return null;
}
@Override
public Double perimeter() {
return null;
}
}
---
package com.morning.test;
public class Demo {
public static void main(String[] args) {
Circle circle = new Circle();
System.out.println(circle.area(6.0,2.0));
Trapezoid trapezoid = new Trapezoid();
System.out.println(trapezoid.area(2.0,4.0,2.0));
}
}
匿名实现类
public class Ch01 {
public static void main(String[] args) {
Ch01 ch01 = new Ch01();
System.out.println("ch01=" + ch01);
Abstr01 a01 = new Abstr01() {
@Override
public void show() {
System.out.println("重写过后的show方法...");
}
};
a01.show();
Abstr01 abstr02 = new Ch02();
System.out.println(a01);
Inter01 inter01 = new Inter01() {
@Override
public void eat() {
System.out.println("重写过后的eat方法...");
}
};
}
队列和栈
栈和队列是两种操作受限的线性表。
这种受限表现在：
栈的插入和删除只允许在表的尾端进行（在栈中叫做“栈顶”），满足FILO（First In Last Out）
队列只允许在表位插入元素，在表头删除元素，FIFO （First In First Out）
栈与队列的相同点：
1.都是线性结构
2.插入操作都是在表尾进行
3.都可以通过顺序结构和链式结构实现。
栈与队列的不同点：
队列，先进先出，栈先进后出
栈
public class Stack {
private SuperLinked superLinked = new SuperLinked();
// 入栈。压栈
public void push(Integer item){
superLinked.add(item);
}
// 返回栈顶元素，不出栈
public Integer peek(){
if(empty()) {
return null;
}
return superLinked.get(superLinked.size() - 1);
}
// 出栈，从栈尾出去
public Integer pop(){
if(empty()) {
return null;
}
Integer integer = superLinked.get(superLinked.get(superLinked.size() - 1));
superLinked.remove(superLinked.size() - 1);
return integer;
}
private boolean empty() {
return superLinked.size() == 0;
}
public static void main(String[] args) {
// 测试
Stack stack = new Stack();
stack.push(1);
stack.push(2);
stack.push(3);
stack.push(4);
stack.pop();
System.out.println(stack.peek());
}
队列
package com.afternoon;
import com.afternoon.linked.SuperLinked;
public class Queue {
private SuperLinked superLinked = new SuperLinked();
// 入队的方法
public void add(Integer item){
superLinked.add(item);
}
// 出队的方法
public Integer poll(){
// 1.判断这个队列是不是空
if(empty()){
return null;
}
// 2.找到队列的头
Integer integer = superLinked.get(0);
// 3.把队伍的头删掉
superLinked.removeFirst();
// 4.返回删除的值
return integer;
}
// 返回队首，不出队
public Integer peek() {
if(empty()) {
return null;
}
return superLinked.get(0);
}
// 判断这个队列是否为空
public boolean empty() {
// if(superLinked.size() == 0){
// return true;
// }
// return false;
return superLinked.size() == 0;
}
public static void main(String[] args) {
Queue queue = new Queue();
queue.add(1);
queue.add(120);
queue.add(50);
queue.poll();
System.out.println(queue.peek());
}
}
总结
* 1、抽象abstract关键字
* 抽象类的特点
* abstract能修饰哪些结构
* 抽象方法的特点
* 2、接口。JDK7-JDK8的有什么改变
* 3、面试题：继承类和实现接口的异同？抽象类和接口的区别
* 4、多态的补充说明。
* 5、匿名实现类
*
* 重点：结合多态，参数的传递，配合instanceof使用
*
* 在能够使用多态表示对象的时候，尽量使用多态。
*
* 栈和队列
* 建立在两个最基础的数据结构的基础上构建的两个受限制的线性表
*
* 面向对象四大特征：
* 封装，继承，多态，（抽象）
标签：26,return,07,接口,superLinked,抽象,2022,抽象类,public 来源： https://www.cnblogs.com/lurui711/p/16522446.html
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。