JAVA基础课程

Posted 2020-10-31

（一）二维数组
二维数组:
数据类型[] [] 数组名 = new 数据类型[m][n] ;
m:代表当前二维数组中有多少个一维数组
n:代表每一个一维数组中的长度

定义的方式还有以下两种情况
    数据类型[]  数组名[] = new 数据类型[m][n]
    数据类型 数组名[][] = new 数据类型[m][n] 

做些需求 要注意定义的具体 类型:
int x;
int x,y ;
int[] x ;
int [] x,y[] ;
二维数组定义的第二种格式:

        数据类型[][] 数组名 = new 数据类型[m][] ;
     只给定有m个一维数组,每一个一维数组长度动态给定

二维数组的格式3
静态初始化
数据类型[][] 数组名称 = {{元素1,元素2,元素3},{....}} ;
（二）代码块
关于代码块的概述:
用{}括起来的代码,统称为代码;
根据其位置以及声明不同:分为以下:
局部代码块: 在main()里面,给变量限定它的生命周期
构造代码块:在一个类中的成员位置中,用{}括起来,
作用:可以将多个构造方法中的相同的代码放到构造代码块中,对对象进行初始化. 在每次执行构造方法之前,先执行构造代码块.
静态代码块:在一个类的成员位置,也是用{}包起来,但是他被static修饰
作用:一般情况 它的作用给类进行初始化
注意：静态代码:只能执行一次
构造代码块在每次执行构造方法之前都会被执行.
（三）final关键字
方法重写:
由于子类继承父类的时候,提供一摸一样的方法声明,然后会将父类该方法覆盖掉(重写,复写)
有时候(具体的需求),不需要子类重写父类的功能,针对这种情况,Java提供了一个关键字:final 最终的,终态的意思
final:表示最终,终态(不能被更改的)
它可以修饰类,那么该类不能继承
它可以修饰成员方法,成员方法不能被重写
它可以修饰变量,此时这个变量是一个常量

常量的分类:
    字面值常量:
        字符串常量,字符常量,,,,

    自定义常量(final修饰的)
        pubic final int num = 100 ;
         final不仅可以修饰基本数据类型
                            还可以引用类型
        如果final修饰的是一个基本数据类型:基本数据类型的值不能再改变了...
        如果final习俗的是一个引用类型数据:引用类型的地址值不能再改变了,但是堆内存中的成员变量的值可以变得

final的初始化时机:
1)被final只能被赋值一次(final int a = 10 )

        final int a ;

    //在使用之前进行初始化,赋值(在构造方法之前赋值) (非静态的...)            

（四）多态
在同一个时刻,体现出来的不同状态;
水:
固态 气态 液态

    猫狗案例的,创建猫的对象
    Cat c = new Cat() ;   猫是猫
    Animal a = new Cat() ;猫属于动物

多态的前提:
1)必须有继承关系
子类继承父类,存在一些特点
2)必须有方法重写
子类继承父类,方法重写的目的,举例:动物吃的方法,每一个具体动物吃的东西不一样,所有必须要方法覆盖
3)就是必须有父类的引用指向子类对象 (向上转型)
父类名 fu = new 子类名() ;

            通过父类对象的创建是通过子类在堆内存新建了了一个对象,由于子类又继承了父类,
                父类的引用(初始化)是通过子类新建对象进行的..

多态中的成员访问特点:
1)成员变量: 编译看左,运行看左...
2)成员方法(非静态): 编译看左,运行看右(存在方法重写)
3)构造方法:构造方法(无论子类,还是父类),都是对对象进行初始化
4)静态成员方法: 编译看左,运行看左(静态跟类有关系,算不上方法重写)
多态的好处:
可以提供代码的复用性:继承保证
可以提高的代码的扩展性:由多态保证... (父类的引用指向子类对象)
多态的弊端:
父类引用指向子类对象,
通过父类的引用调用子类特有功能,不能调用....
不能访问子类特有功能
Father3 f = new Son3()f ; 父类的引用指向子类对象 (向上转型)

    可不可以将子类的引用指父类的引用呢?  (向下转型)
    Son s=（Son） f;将父类的引用强制转换子类的引用
        将父类的引用强制转换子类的引用  ,向下转型使用不当,会出现一个异常:属于运行时期异常:ClassCastException
        **（五）继承**
（1）将多个类抽取位一个独立的类,让独立的类和多个类产生继承关系

    继承 的关键字:extends
    格式:
        class 父类名{
        }
    class 子类名 extends 父类名{
            ...
        }

继承 的好处:
1)提供了代码复用性,解决了代码的臃肿
2)它是多态的前提(多态的前提是必须有继承关系)

继承的特点:
子类继承父类,是继承了父类所有的东西(成员变量,成员方法,包括私有),但是子类不能使用私有的东西,只能通过父类的公共的访问间接的
让子类访问它.
（2）继承的另外一个特点:
在Java中,继承只支持单继承,不支持多继承(子类名 extends 父类名1,父类名2,...)
但是,Java是可以支持多层继承...

类和类之间的关系:继承关系
类和接口之间的关系:实现关系
（3）继承中的注意事项:
1)构造方法不能被继承,但是通过super关键字去访问
2)私有的可以间接的去访问
3)什么时候使用extends？
继承体现的是一种"is a"的关系:
如果A是B的一种或者B是A的一种,这个可以使用继承!
不要随意的使用继承,只要有"is a"的关系就使用它..
Java开发设计原则:
低耦合,高内聚
耦合:类和类之间的关系 ,尽量降低耦合性
内聚:指的是做一件事情能力(尽量使用一个类完成的事情不要多个类去完成..
在继承中,成员变量的名称问题
当前子类继承父类的时候,子类和父类中的成员变量名称不一致的情况,非常简单,分别输出就可以了;
当子类和父类中的成员变量名称一致的情况:
1)先到子类的局部位置找,如果找到了,就输出
2)没有找到,到子类的成员位置找,有就输出,
3)在类的成员位置还没有找到,直接父类的成员位置找,有就输出
4)如果还没有,就保存了,不存在这个变量
（4）super关键字
要访问这个子类的局部位置的变量,直接可以访问.
需求:要访问Son类的成员位置的这个变量nun,如何访问
需求:要访问Father类的成员位置的变量nun.如何访问?
Java提供了关键字:super:代表的父类的空间标识(父类的引用或父类的对象)
this和super关键字的用法:
成员变量:
this:
this.成员变量; (访问当前类)
super:
super.成员变量;(访问父类)

        构造方法:
            this(); //无参构造
            this("") ;//访问当前类的有参构造
            super()://访问的父类的无参构造
            super("")://访问的是父类的有参构造..
        成员方法:
            this.xx()
            super.xx()
    （5） 关于继承的成员的问题
        构造方法:
            子类继承父类,都会默认的访问父类的无参构造方法
            为什么呢?
            假设数据还没有被初始化完毕,所以应该先让父类进行初始化,然后在让子类初始化--->分层初始化
                如果父类的无参构造没有提供?怎么办?
                    肯定报错;
                如何解决:
                    1)可以将父类的无参构造提供出来
                    2)可以super关键字去访问父类的带参构造...
                    3)还可以在子类中通过this(),访问本类中的有参构造,间接的去访问父类带参构造
                    子类的构造方法必须有一个(有参构造/无参构造),让父类进行初始化
    （6）     继承中成员方法的问题
                子类继承父类,访问成员方法名不一致的情况,分别调用!
                当子类中的成员方名和父类中的成员方法名一致的情况:
                            1)现在子类的成员位置找,如果有就调用
                            2)如果没有找到,在父类的成员位置找,有就调用
    （7）关于继承的用法:
                    父类中被private修饰的,是可以继承,但是只能间接的去访问私有的..
                    父类被private修饰 成员属性,子类不不能直接访问的
                    子类不能继承父类的构造方法,但是可以通过super
            **  （六）抽象类**
    （1） 抽象类的概念:
    针对一个事物,比如:动物类---->总体概括,之前定一个具体的动物(---->必须给他的某个功能只是声明即可),只有,猫或者狗等等这些才是具体事物
    Java中,如果一个类中有一个方法声明(抽象方法)抽象功能,那么这个类定义为抽象类

关键字:abstract  抽象的意思
    抽象类的特点:抽象类不能直接实例化!(不能创建对象)      接口也不能实例化
    关于抽象类:
        1)如果一个类中有抽象方法,那么这个类是一定是一个抽象类
        2)抽象类必须有抽象方法吗? 抽象类中不一定都是抽象方法
    抽象类的子类
        1)如果子类是抽象类,没有意义,因为都不能实例化,对象如何创建
        2)子类具体类,那么子类必须实现父类中的抽象功能.
（2） 抽象类的成员特点:
    成员变量:
            可以是变量,也是一个常量
    构造方法:可以有无参,可以有有参,作用:给对象进行初始化的.
    成员方法:可以有抽象方法,还可以有非抽象方法...

abstract和哪些关键字是冲突的,不能共有!

abstract 和private
abstract 和final
abstract和static 

（七）接口
接口:体现的是事务的扩展×××(额外动作,后天经过学习等等)

（1）接口格式(标识符:类,接口:见名知意)
interface 接口名{
//抽象功能
public abstract void jump() ;

    }

接口的特点:不能实例化
接口的子实现类:实现类 (具体的实现类)
class 类名+impl implements 接口名{

    }

接口的子类如果是抽象类:没有意义,不能实例化

接口多态(最多)
抽象类多态(比较多)
具体对象的创建(经常会使用)
（2）接口成员的特点:
成员变量:是一个常量,不能更改,并且默认的修饰符
public static final:
构造方法:接口不存在构造方法
成员方法:都是抽象方法
默认的修饰符:public abstract
(八内部类
实际开发中,接口作为形式参数的问题

    如果形式参数是接口:
                传统的方式:  1)提供给接口的子实现类
                                                             2)内部类的方式(不需要提供子实现类)
（1） 定义:
    在B类内部定义A类,A类就属于B的内部类
    内部类访问外部类的特点:
                它可以直接访问外部了的成员,包括私有
        格式:外部类名.内部类名 对象名 = 外部类对象.内部类对象
    外部类如何访问内部类的成员?
        通过创建内部类对象的方式间接访问...
（2） 内部类的分类:
        成员内部类:在外部类的成员位置
                            可以直接外部类的成员,包括私有
                            外部类要访问内部类(非静态的内部类)的成员方法:
                            格式:外部类名.内部类名 对象名 = 外部类对象.内部类对象
                            关于成员内部类的修饰符:
                                        private:  作用:保证数据的安全性!
                                        static修饰:可以把静态内部类看成是外部类的成员.
                                        特点:
                                                        静态成员内部类访问外部类的数据,该数据必须static修饰

        局部内部类:在外部类的局部位置
                            可以访问外部类的成员包括私有...
                            在外部类的局部位置去访问内部类的show(),需要在局部位置创建内部了对象,通过对象去访问

        匿名内部类
                        前提是有一个类或者接口
                        这个类可以是具体类也可以是抽象类
                    new 类名或者接口名{

                    方法重写();
                    }

                    匿名内部类的本质:
                                是继承了该类或者实现了该接口子类对象...
                **（九）形式参数与返回值**
            （1） 形式参数的问题:
                        形式参数是基本类型,对实际参数没有影响(简单)
                        形式参数是引用类型:
                                类(普通类)
                                抽象类

• 引用类型:是一个抽象类
• 形式参数是一个抽象类:此时这块需要的是该抽象类的子类对象 (抽象类多态...)

• */
  //抽象的Person类
  abstract class Person{
  public void teach() {
  System.out.println("今天天气不错,适合踢球...");
  }
  }

class PersonDemo{
public void method(Person p) { //不能直接创建对象 Person p =new Person(); 可以采用抽象类多态的形式实现
p.teach();
}
}

//需要提供Pereson类的子类
class Teacher extends Person{

}
//测试类
public class TeacherTest {

public static void main(String[] args) {
    //需求:需要调用PersonDemo类中的method()方法
    //创建PersonDemo对象
    PersonDemo pd = new PersonDemo() ;

// Perosn p = new Person() ; //错误的,抽象类是不能实例化的
//可以通过子类进行实例化
Person p = new Teacher();
pd.method(p);
}
}

                                接口
                                        形式参数是一个接口:

//定义一个接口
interface Inter{
    public abstract void study() ;
}

class InterDemo{
    public void show(Inter i) { //需要创建该接口对象,不能直接实例化 Inter i = new Inter() ;错误的
                                //需要提供接口的子实现类,可以通过子实现类进行实例化:接口多态...
        i.study();
    }
}

//子实现类
class Student2 implements Inter{

    @Override
    public void study() {
        System.out.println("Good Good Study ,Day Day Up ...");
    }

}

//测试类
public class StudentTest {``

    public static void main(String[] args) {
        //需求:需要调用InterDemo这个了中的show()方法,如何调用
        //创建InterDemo类的对象
        InterDemo id = new InterDemo() ;
        //接口多态的形式创建Inter对象
        Inter i = new Student2() ;
        id.show(i);

        /*Inter i2 = new Inter() {

            @Override
            public void study() {
                //实际开发中要比第一种多
            }
        };*/

    }
}

            （2）返回值:
                                    如果返回值基本类型:用对应的基本类型去接收数据即可!
                            引用类型:
                                        类(具体类): 需要的是该类的对象
                                        抽象类
                                        接口