要突击两场考试了,暂且抽时间学一下Java吧
文章目录
Super关键字
“代表当前对象的父类特征”。表示通过子类的构造方法调用父类的构造方法 。模拟现实世界的:要想有儿子,需要先有父亲
语法:
1. super.
2. super()
当一个构造方法中的第一行:
既没有this()又没有super(),默认会有一个super()来调用父类的无参构造方法
this()和super()是不能并存的,两者都只能出现在 构造方法的第一行。
无论如何,父类的构造方法是一定会执行的
该方法和this()对比着看,this()是调用本类中另一个构造方法,而super是调用父类中的构造方法
在Java中,无特殊说明继承关系的话,默认是继承自Object类,它是“老祖宗”
因此在执行时Object类的无参数构造方法一定会被执行,它处于“栈顶”
package Demo;
public class Test_super {
public static void main(String[] args){
new B(66);
}
}
class A{
public A(){
System.out.println("A类的无参数构造方法");
}
public A(int i ){
System.out.println("A类的有参数构造方法");
}
}
class B extends A{
public B(){
super(6); //没写的话默认有一个super(),表示调用父类的无参数构造方法
System.out.println("B类的无参数构造方法");
}
public B(int i ){
this(); //调用本类的无参数构造方法
System.out.println("B类的有参数构造方法");
}
}
/*
A类的有参数构造方法
B类的无参数构造方法
B类的有参数构造方法
*/
IDEA 快捷键
快速生成main方法 psvm 或者 main
快速生成System.out.println(); sout
删除行 Ctrl+Y
新增、新建、添加 Alt + insert
切换窗口 Ctrl + TAB 或者 Alt + 左右箭头
移动代码块 Ctrl + ALT + 方向键
右侧Project栏列表的展开关闭 左箭头关闭 右箭头展开
提示参数 Ctrl + P
单行注释 Ctrl + /
多行注释 Ctrl + shift + /
打开设置面板 Ctrl + Alt + s
查看当前类的层次结构 Ctrl + H
快速检索类 Ctrl + N
final关键字
final 表示最终的、不可改变的
final 可以修饰变量以及方法,还有类等
- final 修饰的类无法被继承
- final 修饰的方法无法被重写
- final 修饰的变量只能赋一次值
final class String{}
public final void A(){}
final int dmind = 666;
final修饰的实例变量:
如果没有给实例变量赋值的操作,则会报错: 可能尚未初始化变量i
- 实例变量在什么时候赋值?
在构造方法执行的时候赋值(new的时候赋值)
两种赋值方法:
- 可以在直接赋值:
final int i =666;
- 可以在构造方法中赋值,如下
package Demo;
public class Test_final {
public static void main(String[] args) {
C dmind = new C(5);
System.out.println(dmind.i);
}
}
class C {
final int i ; //也可以这样赋值:final int i = 666 ;
public C(int i){ //实例变量在构造方法中赋值,不会报错。
this.i = i;
}
}
总之,一定要记得给final修饰的变量赋值,系统不参与赋值!!
常量
常量的值不可改变。常量和静态变量都是存储在方法区,并且都是在类加载时初始化。
常量建议全部大写,各个单词之间才有下划线衔接
public static final int MAX_NUMBERS = 100;
- 只用final修饰,值一定不变,但该变量可能有多份(内存空间中有多份)
- 只用static修饰,可以保证唯一,但不能保证变量不被修改
- final与static一起修饰,既保证不被修改,也保证唯一。
抽象类(abstract)
类与类之间具有共同的特征,将这些共同特征提取出来形成的就是抽象类。
语法:
[修饰符列表] abstract class 类名{
类体;
}
抽象类是用来被子类继承的。
抽象方法:没有实现的方法,没有方法体的方法。
public abstract void something();
特点:
- 没有方法体,即没有大括号。以分号结尾
- 修饰符列表中要有 abstract 关键字
抽象类中可以没有抽象方法,有非抽象的方法。但抽象方法一定出现在抽象类中
子类是abstract类,允许子类将父类的非abstract方法重写为sbstract方法
重点:一个非抽象的类,继承抽象类,必须将抽象类中的抽象方法进行覆盖/重写/实现
final
和abstract
不能联合使用、不允许使用static
修饰abstract方法,否则如何覆盖/重写/实现?
package Demo;
public class Test_abstract {
public static void main(String[] args){
}
}
//定义一个抽象类
abstract class Accounts{
public void dosomething(){} //抽象类中可以有非抽象方法
public abstract void doOther(); //抽象方法,没有方法体,不能加括号
}
//定义一个非抽象类
class CreditAccounts extends Accounts{
public CreditAccounts(){ //构造方法,默认调用super()
super();
}
public void doOther(){} //因为本类不是abstract,要重写父类中的抽象方法,把abstract去掉
}
接口(interface)
- 接口是完全抽象的,抽象类是半抽象的,接口是一种特殊的抽象类
- 接口支持多继承,一个接口继承多个接口
- 定义
[修饰符列表] interface 接口名{}
interface A{}
interface B extends A{}
- 接口中只包含两部分内容:常量、抽象方法
- 接口中所有元素都是public 修饰的,都是公开的
- 接口中定义常量,可以省略
public static final
修饰符。 - 接口中所有方法都是抽象方法,因此都没有方法体;定义抽象方法时,可以省略
public abstract
修饰符。 - 定义接口时,在interface前加上public关键字,这样的接口是一个public接口,可以在任何一个类实现。如果不加上public修饰,就称为友好接口,可以被与该接口在同一包中的类实现。
例子:
package Demo;
public class Test_interface {
public static void main(String[] args) {
System.out.println(Mymath.PI);
}
}
interface Mymath{
//接口中定义常量,可以省略public static final。下面两个等效
double PI1 = 3.1415926;
public static final double PI = 3.1415926;
//接口中定义抽象方法,可以省略public abstract。下面两个等效
int add1(int a,int b);
public abstract int add(int a,int b);
}
类实现接口
- 类和类之间叫做继承、类和接口之间叫做实现。
- 当一个非抽象的类实现接口,必须将接口中所有的抽象方法全部实现
package Demo;
public class Test_interface1 {
public static void main(String[] args) {
MyMathImp a = new MyMathImp();
System.out.println(a.sum(4,21)); //25
}
}
//定义MyMath接口
interface MyMath{
double PI = 3.14;
int sum(int a, int b);
int sub(int a, int b);
}
//定义一个非抽象类MyMathImp,继承MyMath接口
class MyMathImp implements MyMath{
public int sum(int a, int b){
return a+b;
}
public int sub(int a, int b){
return a-b;
}
}
接口与多态的联合
package Demo;
public class Test_interface1 {
public static void main(String[] args) {
//父类型的引用指向子类型的对象
MyMath dd = new MyMathImp();
//调用接口中的方法
dd.sub(4,5);
//dd.kk(4); 此行是错误的,父类型(即接口)中不存在此方法
}
}
//定义MyMath接口
interface MyMath{
double PI = 3.14;
int sum(int a, int b);
int sub(int a, int b);
//int kk (int a);
}
//定义一个非抽象类MyMathImp,继承MyMath接口
class MyMathImp implements MyMath{
public int sum(int a, int b){
return a+b;
}
public int sub(int a, int b){
return a-b;
}
public int kk (int a){
return a;
}
}
一个类可以实现多个接口
一个类可以同时实现多个接口。这种机制弥补类java中:类和类只支持单继承的缺陷。
public class Test_interface2 {
public static void main(String[] args) {
D foo = new D();
foo.B();
//向上转型
A bar = new D();
bar.A();
//接口转型,从A接口转为B接口,调用其独有的方法
B dd = (B) bar;
dd.B();
//下面两行运行会报错,但编译不会:ClassCastException: D cannot be cast to C
//接口和接口之间在强制类型转换时,即使没有继承关系也能强转,编译没问题,但运行报错
D kk = new D();
C tt = (C) kk;
}
}
interface X{
}
interface Y{
}
//接口与接口之间可以多继承,extendes
interface Z extends X,Y{
}
interface A{
void A();
}
interface B{
void B();
}
interface C{
void C();
}
//一个类实现多个接口,类似于多继承
class D implements A,B{
public void A(){
System.out.print("A方法");
}
public void B(){
System.out.print("B方法");
}
}
一个类同时继承父类、实现接口
继承与实现都存在,则 extends 关键字在前, implements关键字在后
public class Test_interface3 {
public static void main(String[] args){
Flyable cat = new Cat(); //多态
cat.fly();
Flyable pig = new Pig(); //多态
pig.fly();
}
}
interface Flyable{ //具有飞功能
void fly();
}
//父类
class Animal {
}
//extends 关键字在前, implements关键字在后
class Cat extends Animal implements Flyable{
//必须实现接口的方法
public void fly(){
System.out.println("能飞的猫");
}
}
class Pig extends Animal implements Flyable{
public void fly(){
System.out.println("能飞的猪");
}
}
类和类之间的关系
is a 继承关系
Cat is a Animal
例如:Cat extends Animal //Cat继承Animal
has a 关联关系,以属性方式存在
A has a B
例如:class A{
B b; //B以成员变量的形式存在于A中
}
like a 实现关系
Cook like a Foodmenu
例如: class Cook implements Foodmenu{} //类实现接口
抽象类与接口区别
抽象类是半抽象的
接口时完全抽象的
抽象类中没有构造方法
接口中没有构造方法
接口和接口之间支持多继承
类和类之间只能单继承
一个类可以同时实现多个接口
一个抽象类只能继承一个类(单继承)
接口中只允许出现常量和抽象方法
一般接口使用的比较多,一般抽象类使用比较少
接口一般都是对“行为”的抽象