第三周总结

class Father{
    //父类的无参构造方法
   /* public Father(){
        System.out.println("Fu的无参构造方法...");
    }*/
    public Father(String name){
        System.out.println("Fu的有参构造方法...");
    }
}
//子类
class Son extends  Father{
    public Son(){
        super("随便给") ;
        System.out.println("Zi的无参构造方法");
    }
    public Son(String name){
       // super("随便给") ;
        this() ;//访问本类的无参构造方法
        System.out.println("Zi的有参构造方法");
    }
}
//测试类
public class ExtendsDemo2 {
    public static void main(String[] args) {

        Son s = new Son() ;
        Son s2 = new Son("高圆圆") ;
    }
}

7.20日

一、this 和 super的区别

this：代表当前类对象的地址值引用

super：代表父类对象的地址值引用（代表父类的空间标识）

访问成员变量：

this.变量名：访问本类中的成员变量

super.变量名：访问父类的成员变量

访问构造方法：

this（）：访问本类中的无参构造方法

super（）：访问父类中的无参构造方法

this(xxx)：访问本类中的有参构造方法

super（xxx）：访问父类中的有参构造方法

成员方法：

this.方法名（）：访问本类的成员方法

super.方法名（）：访问父类的成员方法

二、方法重写（Override）

1.定义：如果子类出现了和父类一模一样的方法声明，叫方法重写。

权限修饰符返回值类型方法名(参数列表){
...
}

2.方法重写和方法重载的区别有哪些

方法重载：在一个类中，提供多个方法名相同，参数列表不同与返回值无关的方法。

目的：来扩展这个方法的功能性。

参数列表不同指：类型、参数个数、参数类型顺序都不同

构造方法也可以重载。

方法重写：在继承关系中，子类出现了与父类一模一样的方法声明。

重写的目的：子类有自己的功能，需要将父类的该功能覆盖掉

三、final关键字

final：最终的无法更改的。

特点：

1）可以修饰类，该类不能被继承

2）可以修饰成员方法，该方法不能被重写

3）可以修饰变量，这个变量此时为常量且数值只能定义一次

final修饰基本数据类型和引用类型有什么区别？

基本类型：

基本数据类型对应的数据不能再被赋值，只能赋值一次。

引用数据类型：

引用数据类型对应的地址值不能被改变。

 final Student s = new Student() ;//修饰实例变量s,s的堆内存地址值永远是固定值!                           
    
    s = new Student() ;//重新开辟空间(报错)

开发中定义常量：

public static final int A=100；//自定义常量

public static final Student s=new Students();//成员位置定义的静态实例变量

final的使用示例：

class Student{
    //系统默认无参构造
    int age = 20 ;
}
public class FinalDemo3 {
    public static void main(String[] args) {

        //没有使用final之前
        int a = 10 ;
        a = 30 ;
        a = 100 ;
        a = 40 ;
        System.out.println("a:"+a);
        System.out.println("--------------------------");
        //final修饰基本类型
        final int b = 20 ;   //编译时期常量 (jvm不需要加载,检查语法)
        //b = 50 ;
        System.out.println("b:"+b);

        System.out.println("--------------------------");

        //没有使用final修饰的引用类型
        Student s = new Student() ;//堆内存中创建了一个空间地址
        s.age = 40 ;
        System.out.println(s.age);
        System.out.println(s);
        s = new Student() ;
        System.out.println(s);
        System.out.println("--------------------------");
        //final修饰引用数据类型

        final Student s2 = new Student() ; //运行时期常量(需要jvm加载这个类的),堆内存空间地址值不能被改变!
        System.out.println(s2);
        s2.age = 50 ;
        System.out.println(s2.age);
       //  s2 = new Student() ; //不能开辟新的堆内存地址,但是里面的成员变量继续更改!
    }
}

四、多态

1.定义：

一个事物在不同时刻的不同状态。

举例：程序中，猫是动物 Animal a=new Cat();

猫是猫 Cat c= new Cat();

2.多态的前提条件：

1）必须存在继承关系（extends）

2）必须存在方法重写

子类需要覆盖父类的功能


 /*                     Animal
 *                              eat():"动物都需要吃饭..."
 *                      Cat
 *                              eat() "猫吃鱼"
 *                      Dog
 *                              eat() "狗吃骨头"*/

3）必须有父类引用指向子类对象

class Fu{}
class Zi extends Fu{
    //存在重写
}
//格式：  Fu  fu= new Zi();

3.多态成员的访问特点：

Fu fu = new Zi();

1）针对成员变量的访问：编译看左，运行看左（使用父类的东西）

2）针对多态中的成员方法的访问：编译看左，运行看右（子类重写父类）

3）如果成员方法为静态方法：编译看左，运行看左（静态方法不存在重写）

4）构造方法：需要分层初始化

4.多态的好处

1）提高了代码的复用率

2）提高了代码的扩展性

5.多态的弊端

不能访问子类的特有功能（Fu f = new Zi（）；）

此时 f.方法名（）；报错。因为父类没有子类的特有功能

如何解决？

方案一：不推荐

具体的子类创建具体的子类对象：Zi z = new Zi（）；

z.成员方法名（）；

本身Fu f = new Zi();已经在堆内存中开辟了空间，Zi z = new Zi();又要在堆内存中开辟空间，比较消耗内存。

方案而：向下转型

Zi z = new (Zi) f;还原成子类型

强制类型转换：目标类型变量名 =（目标类型）初始化值；

//父类
class Father2{
    public void show(){
        System.out.println("show father...");
    }
}
//子类
class Son2 extends  Father2{
    public void show(){
        System.out.println("show son...");
    }
    //特有功能:
    public void playGame(String gameName){
        System.out.println("会玩"+gameName+"游戏");
    }
}
//测试类
public class DuoTaiDemo4 {
    public static void main(String[] args) {
        //父类指向子类对象
        Father2 father2 = new Son2() ;
        father2.show(); //编译看左,运行看右,存在重写
        //father2.playGame( "lol");//父类没有方法
        System.out.println("------------------------------");
        //方案1:创建具体的子类对象
        Son2 son2 = new Son2() ;
        son2.playGame("lol");
        System.out.println("------------------------------");
        /**
         * "向下转型"
         *                            Zi z =   (Zi)f ;  还原成子类型
         */
        Son2 s = (Son2) father2;
        s.playGame("csgo");
    }
}

7.21~22日

一、多态向下转型时出现异常

要向下转型，前提必须要有父类引用指向子类的对象 Fu f = new Zi();

遵循向下转型的格式： Zi z = (Zi) f;此时心里要清楚堆内存中存储的类型

向下转型使用不当，就会出现java.lang.ClassCastException:类转换异常: (属于运行时期异常)
当前堆内存中的实例不是该类型时,就会出现问题!

class Animal{
    public void eat(){
        System.out.println("动物都需要吃饭");
    }
}
//狗类
class Dog extends  Animal{
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}
//猫类
class Cat extends  Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
//测试类
public class DuoTaiDemo {
    public static void main(String[] args) {
        //多态版测试猫
        Animal a = new Cat()  ;//此时 堆内存是猫       (猫是动物)
        Cat c = (Cat) a ;  //还原成猫类型  :猫是猫
        a = new Dog() ; //此时:堆内存是狗   (狗是动物)
        Dog d = (Dog)a; //还原成狗的类型: 狗是狗
        Cat cc = (Cat)a ;//现在没有报错:语法正确的:符合强转类型语法格式，但是运行会报类转换异常
    }
}

二、抽象类

1.什么是抽象类

将某个事物中的一些功能仅仅给出声明即可，没有方法体-------->抽象方法------->此时这个类为抽象类。

关键字：abstract

抽象方法：权限修饰符（一般是public）abstract 返回值类型方法名（形式参数列表）；

抽象类格式： abstract class 类名{ }

2.抽象类的特点：

1）有抽象方法的类一定是抽象类

2）抽象类中不一定只有抽象方法，也可以有非抽象方法

3）抽象类不能实例化（不能new）

4）抽象类的子类有两种情况

①子类也是抽象类：毫无意义，因为子类也不能new，除非子类再有具体的子类。 ②子类是具体类：抽象类多态： Fu fu = new Zi();

3.抽象类的核心宗旨：

强制子类必须完成的事情（要将父类中所有的抽象方法重写，否则报错）

4.抽象类的成员特点

成员变量：既可以定义变量，也可以定义常量;被final修饰

成员方法:既可以定义为抽象方法，也可以定义为非抽象方法

如果定义为抽象方法必须给出关键字abstract

构造方法：存在无参构造/有参构造方法------>目的：为了分层初始化

5.继承中父子类权限问题

如果当前子类继承父类的时候，存在方法重写，那么子类重写父类该方法访问权限不能更低。要么和父类方法权限保持一致，要么带上public（推荐和父类方法保持一致即可）

6.一个类中没有抽象方法，那么将这个类定义为抽象类的意义是什么？

为了不让它直接实例化。

7.abstract和哪些关键字冲突？

private冲突：私有的方法，只能在本类中访问，加入abstract的目的需要被子类重写，需要调用子类的功能。

static冲突：静态方法随着类的加载而加载，而静态方法算不上重写，所以它的访问通过

类名.方法名（）访问，而抽象方法没有方法体。

final冲突：被final修饰的成员方法不能被重写，而加入abstract的方法需要被重写。

8.abstract可以跟的关键字

public

默认修饰符

protected：受保护的（范围：同一个包下的当前类或者子类中或者不同包下的子类中）

abstract一般在类上使用：抽象类

在方法上使用：抽象方法

在接口中使用

三、接口

1.什么是接口

接口：体现了一个现实世界事物所具有的额外的拓展功能

定义格式： interface 接口名 { }

接口中的方法：不能有方法体，隐藏public abstract 关键字，只能是抽象方法，不能有方法体

2.接口的特点：

1）不能实例化（不能new对象）

2）如何实例化

接口实例化：通过接口的子实现类（一般是具体的类）进行实例化--------接口多态

子实现类和接口的关系：implements 实现关系

接口的子实现类如果是抽象类，那么抽象类必须存在具体的子类，否则都不能实例化。

3.接口的命名规则：

开发中：在接口名的后面+Impl：子实现类

4.接口的成员特点

1）接口中的成员方法：只能是抽象方法，默认修饰符：public abstract可以省略不写

2）接口中的成员变量只能是常量

3）接口中没有构造方法

5.接口和抽象类的区别

1）成员的区别：

抽象类中： ①成员变量：既可以是常量，也可以是变量。

②成员方法：既可以是抽象方法，也可以是非抽象方法。

③构造方法：既存在无参构造方法，也可以存在有参构造方法。

接口中：①成员变量：只能是常量，存在默认的修饰符public static final（可以省略）。

②成员方法：只能是抽象方法，存在默认修饰符public abstract省略不写。

③构造方法：没有，因为接口中的方法都没有方法体

2）关系的区别：

类与类的关系：继承，只支持单继承，不支持多继承，但是可以多层继承

类与接口的关系：实现，一个类继承另一个类的同时，也可以实现多个接口

接口与接口的关系：继承，不仅支持单继承，也支持多继承，还可以多层继承

3）设计理念的区别：

抽象类不能实例化，但是可以通过具体的子类实例化，存在继承关系体现的是"is a"的关系

接口不能实例化，但是可以通过具体的子实现类来实例化，谁如果实现了接口，它就具备了该接口的功能体现“like a”的关系

6.instanceof 关键字 true/false

提供操作符号，描述左边的对象是否是当前右边类型的实例

7.选择排序

思想规律：

使用0角标对应的元素一次与后面角标对应的元素进行比较，小的往前放，第一次比较完成最小值出现在最小索引处，依次这样比较，比较的次数为数组长度减一次。

核心代码：

 public static void selectSort(int[] arr) {
        for (int x = 0; x < arr.length-1; x++) {
            for (int y = x + 1; y < arr.length; y++) {
                //如果后面的 元素比前面小,互换
                if (arr[y] < arr[x]) {
                    int temp = arr[x];
                    arr[x] = arr[y];
                    arr[y] = temp;
                }
            }
        }
    }

8.异常的归纳

NullPointerException：空指针异常，过程中的变量未赋值导致，找到变量重新赋值
ArrayIndexOutOfBoundsException：数组角标超限异常，数组运算中数组的角标超过数组长度导致，更改数组长度或者更改限制条件
ClassCastException：类转换异常，当试图将对象强制转换为不是实例的子类时，抛出该异常。检查对象是否已有其他含义

7.23日

一、形式参数问题的研究：引用类型

1.如果方法的形式参数是具体类

调用该方法，实际参数需要传递当前具体类的对象

class Student{
    public void  study(){
        System.out.println("学习JavaEE...");
    }
}
class StudentDemo{
    public void method(Student s){
        s.study() ;
    }
}
//测试类
public class StudentTest {
    public static void main(String[] args) {
        //需要访问StudentDemo中的method 方法?
        //创建StudentDemo类对象
        StudentDemo sd = new StudentDemo() ;
        //创建一个具体的学生对象
        Student student = new Student() ;
        sd.method(student);
        System.out.println("-----------------------");
        //或者匿名对象
        new StudentDemo().method(new Student());
    }
}

2.如果方法的形式参数是抽象类

调用还方法实际参数需要传递的是抽象类的子类对象（抽象类多态）

abstract  class Person{
    //定义一个抽象方法
    public abstract  void work() ;
}
//PersonDemo类
class PersonDemo{
    public void show(Person person){    //形式参数是一个抽象类的情况:  Person  p  =   new Programmer();
        person.work();      //p.work();
    }
}
//定义Person抽象类的子类
class Programmer extends  Person{
    @Override
    public void work() {
        System.out.println("程序员不断的去学习...");
    }
}
//测试类
public class PersonTest {
    public static void main(String[] args) {
        //需求:要访问PersonDemo类中的show方法?实际参数如何传递?
        //创建PersonDemo类对象
        PersonDemo pd = new PersonDemo() ;
       // Person p = new Person() ; //抽象类不能实例化!   需要借助子类来进行实例化(存在具体的子类)
        //抽象类多态
        Person p = new Programmer() ;
        pd.show(p);
        System.out.println("-----------------------------");
        //匿名对象
        new PersonDemo().show(new Programmer());
     }
}

3.如果方法的形式参数是接口

调用该方式，实际参数需要传递的是当前接口的子实现类对象（接口多态）

//定义一个接口
interface Love{
    void love() ;
}
//LoveDemo类
class LoveDemo {                        //Love love = new LovePerson() p
    public void function(Love l){//方法的形式参数是接口类型,必须传递接口的子实现类对象
        l.love();//love.love() ;
    }
}
//定义一个接口的子实现类
class LovePerson implements  Love{
    @Override
    public void love() {
        System.out.println("爱生活,爱Java,爱高圆圆...");
    }
}
//测试类
public class LoveTest {
    public static void main(String[] args) {
        //需要访问LoveDemo类中的function方法
        //创建LoveDemo类对象
        LoveDemo ld = new LoveDemo() ;
        //Love love  = new Love() ; //接口不能实例化
        //接口多态
        Love love = new LovePerson() ;
        ld.function(love) ;
        System.out.println("------------------------");
        //匿名对象
        new LoveDemo().function(new LovePerson());
    }
}

二、如果一个方法的返回值是引用类型，最终方法结束该如何返回？

1.具体类

方法返回的就是当前具体类对象

class Student{
    public void study(){
        System.out.println("Good Good Study,Day Day Up!");
    }
}
//StudentDemo类
class StudentDemo {
    public Student show() { //方法的返回值是引用类型---具体类 :需要返回的当前类的具体对象
      /*  Student student = new Student() ;
        //???
        return student ;*/
        //匿名对象
        return new Student();
    }
}
//测试类
public class StudentTest {
    public static void main(String[] args) {
        //调用StudentDemo类中的show方法?
        //创建StudentDemo类对象
        StudentDemo sd = new StudentDemo() ;
        Student s = sd.show(); //Student s = new Student();  sd.show()---->返回的具体的学生对象
        s.study();
        System.out.println("-----------------------");
        //匿名对象
        Student student = new StudentDemo().show();
        student.study();
    }
}

2.抽象类

需要返回的是抽象类的子类对象

//抽象类
abstract class Person{
    public  abstract void work() ;
}
//PersonDemo类
class PersonDemo{
    public Person method(){ //返回值类型是一个引用类型---抽象类的情况,需要返回的是抽象类的子类对象
        //return ?
       // Person p = new Person() ;//抽象类不能实例化
        //抽象类多态
       // Person p = new Worker() ;
        //return p ;
        //一步走
        //匿名对象
        return new  Worker() ;
    }
}
//定义一个子类 继承Person类
class Worker extends  Person{
    @Override
    public void work() {
        System.out.println("工人不断的去工作...");
    }
}
//测试类
public class PersonTest {
    public static void main(String[] args) {
        //需要调用PersonDemo类中的method 方法?
        PersonDemo pd = new PersonDemo() ;
        Person person = pd.method(); // method方法其完成了一件事件: Person person  = new Worker() ;
        person.work() ;
        System.out.println("---------------------------------");
        //匿名对象
        Person p = new PersonDemo().method();
        p.work() ;
    }
}

3.接口

需要返回的是该接口的子实现类对象

//定义一个接口
//结婚的接口
interface  Mary{
    public abstract  void mary() ;
}
//MaryDemo类
class MaryDemo{
    public Mary function(){//返回值类型是接口类型,
        //return ?
        //  Mary mary = new Mary() ; //接口不能实例化
        //需要提供接口的子实现类对象
        //接口多态
       // Mary mary = new You() ;
       // return mary ;
        //一步走
        return new You() ;
    }
}
//定义一个类
class You implements  Mary{
    @Override
    public void mary() {
        System.out.println("结婚了,很开心...");
    }
}
//测试类
public class LoveTest {
    public static void main(String[] args) {
        //调用MaryDemo类中的function方法?
        MaryDemo maryDemo = new MaryDemo() ;
        Mary mary = maryDemo.function();
        mary.mary();
        System.out.println("----------------------");
        //匿名对象
        Mary m = new MaryDemo().function();
        m.mary();
    }
}

三、包（package）

1.包的真实含义：

以后要进行代码分层，然后将包进行划分。开发中，写包名的时候（字母都是小写，多级包）：公司域名反写：com.baidu.pojo....

四、权限修饰符

权限修饰符有：public 、protected 、private、默认修饰符

权限修饰符的范围：

	同一包下的当前类中	同一报下子类/无关类中	不同包下的子类中	不同包下的无关类中
private	√
默认修饰符	√	√
protected	√	√	√
public	√	√	√	√

五、内部类

1.定义：

在一个类中可以定义另一个类，即在类A中定义了类B，将类B就称为类A的内部类

2.成员内部类：

在一个类的成员位置中定义了另一个类。

内部类可以访问外部类的所有成员，包括私有的。

3.私有化成员内部类的访问

在成员内部类前加入private修饰：为了数据的安全性，它的访问就需要外部类的公共访问方法间接访问。

   class Body{
               //内部类:心脏
            private  class Heart{  //加入private:保证数据的安全性
                       //手术
                    public void operator(){
                        System.out.println("心脏搭桥手术....") ;
                    }
               }
                //外部类提供一些公共访问
               public void method(){
 
                   if("如果你是外科医生"){
                       Heart heart = new Heart() ;
                       heart.operator() ;
                   }
               }
           }
           //外部类直接访问成员内部类的成员
           格式:外部类名.内部类名 对象名 = 外部类对象.内部类对象;
          // Body.Heart bh = new Body().new Heart() ;  //加入私有修饰
           // bh.operator() ;

4.外部类直接访问成员内部类的成员：

格式：外部类名.内部类名对象名 = 外部类对象.内部类对象；

//Body.Heart bh= new Body ( ) .new Heart ( );

//bh.operator( );

5.如果当前成员内部类是静态的，里面的方法无论是静态的还是非静态的，都只能访问外部类的静态成员，包括私有的。

6.如何直接访问静态成员内部类的成员？

将静态的成员内部类看作是外部类的静态成员访问。

直接访问方式：

外部类名.内部类名对象名 = new 外部类名.内部类名（）；

class Outer3{
    //定义非静态的成员变量
    public int num = 50 ;
    private static int num2 = 20 ;
    //定义成员内部类:静态的           ---->静态的成员内部类可以看成是外部类的静态成员
    static class Inner3{//此时类都是静态
        public void show(){
           // System.out.println(num);
            System.out.println(num2);
        }
        public static void show2(){
           // System.out.println(num);
            System.out.println(num2);
        }
    }
}
//测试类
public class InnerClassDemo3 {
    public static void main(String[] args) {
        // 外部类名.内部类名 对象名  = 外部类对象.内部类对象;
        //Outer3.Inner3 oi = new Outer3().new Inner3() ;  适用不了了
        //   外部类名.内部类名 对象名 = new 外部类名.内部类名() ;
        Outer3.Inner3 oi = new Outer3.Inner3() ;
        oi.show();
        oi.show2() ; //静态---不推荐对象名访问
        System.out.println("------------------------------");
        //show2()的另一种方式
        Outer3.Inner3.show2(); //show2()静态方法
    }
}