面向对象二

final关键字：

关键字是最终的意思，可以修饰类，成员，变量，成员方法。

修饰类：该类不能被继承

修饰变量：变量就变成的常量，只能被赋值一次

修饰方法：方法不能被重写

final修饰局部变量的问题：

基本类型：基本类型的值不能发生改变。
引用类型：引用类型的地址值不能发生改变，但是，该对象的堆内存的值是可以改变的。

final修饰变量的初始化时机

A:被final修饰的变量只能赋值一次。
B:在构造方法完毕前。(非静态的常量)

多态：

多态的前提：

A:要有继承关系。
B:要有方法重写。
其实没有也是可以的，但是如果没有这个就没有意义。
动物 d = new 猫();
d.show();
动物 d = new 狗();
d.show();
C:要有父类引用指向子类对象。
父 f = new 子();

多态中的成员访问特点：

A:成员变量
编译看左边，运行看左边。
B:构造方法
创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化。
C:成员方法
编译看左边，运行看右边。
D:静态方法
编译看左边，运行看左边。
(静态和类相关，算不上重写，所以，访问还是左边的)

由于成员方法存在方法重写，所以它运行看右边。

多态中的转型问题：

多态的弊端：
不能使用子类的特有功能。

我就想使用子类的特有功能?行不行?
行。

怎么用呢?
A:创建子类对象调用方法即可。(可以，但是很多时候不合理。而且，太占内存了)
B:把父类的引用强制转换为子类的引用。(向下转型)

对象间的转型问题：
向上转型：
Fu f = new Zi(); 转成爹就可以用爹的技能。
向下转型：
Zi z = (Zi)f; //要求该f必须是能够转换为Zi的。

例子：

/*
    多态的弊端：
        不能使用子类的特有功能。

    我就想使用子类的特有功能?行不行?
        行。

    怎么用呢?
        A:创建子类对象调用方法即可。(可以，但是很多时候不合理。而且，太占内存了)
        B:把父类的引用强制转换为子类的引用。(向下转型)

    对象间的转型问题：
        向上转型：
            Fu f = new Zi();
        向下转型：
            Zi z = (Zi)f; //要求该f必须是能够转换为Zi的。
*/
class Fu {
    public void show() {
        System.out.println("show fu");
    }
}

class Zi extends Fu {
    public void show() {
        System.out.println("show zi");
    }

    public void method() {
        System.out.println("method zi");
    }

}

class test1 {
    public static void main(String[] args) {
        //测试
　　　　//向上转型
        Fu f = new Zi();
        f.show();
//        f.method();

        //创建子类对象
//        Zi z = new Zi();
//        z.show();
//        z.method();

        //你能够把子的对象赋值给父亲，那么我能不能把父的引用赋值给子的引用呢?
        //如果可以，但是如下
　　　　
　　　　 //向下转型

        Zi z = (Zi)f;
        z.show();
        z.method();
    }
}

 抽象类：

抽象类的概述：

动物不应该定义为具体的东西，而且动物中的吃，睡等也不应该是具体的。
我们把一个不是具体的功能称为抽象的功能，而一个类中如果有抽象的功能，该类必须是抽象类。

抽象类的特点：

A:抽象类和抽象方法必须用abstract关键字修饰
B:抽象类中不一定有抽象方法,但是有抽象方法的类必须定义为抽象类
C:抽象类不能实例化
　　因为它不是具体的。
　　抽象类有构造方法，但是不能实例化?构造方法的作用是什么呢?
　　用于子类访问父类数据的初始化
D:抽象的子类
　　a:如果不想重写抽象方法，该子类是一个抽象类。
　　b:重写所有的抽象方法，这个时候子类是一个具体的类。

抽象类的实例化其实是靠具体的子类实现的。是多态的方式。
Animal a = new Cat();

abstract class Animal {
    //抽象方法
    //public abstract void eat(){} //空方法体,这个会报错。抽象方法不能有主体
    public abstract void eat();
    
    public Animal(){}
}

//子类是抽象类
abstract class Dog extends Animal {}

//子类是具体类，重写抽象方法
class Cat extends Animal {
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

class AbstractDemo {
    public static void main(String[] args) {
        //创建对象
        //Animal是抽象的; 无法实例化
        //Animal a = new Animal();
        //通过多态的方式
        Animal a = new Cat();
        a.eat();
    }
}

抽象类的成员特点：

成员变量：既可以是变量，也可以是常量。
构造方法：有。
　　用于子类访问父类数据的初始化。
成员方法：既可以是抽象的，也可以是非抽象的。

抽象类的成员方法特性：

A:抽象方法 强制要求子类做的事情。
B:非抽象方法 子类继承的事情，提高代码复用性。

注意：

一个类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?
A:可以。
B:不让创建对象。

abstract不能和哪些关键字共存?
　　private 冲突
　　final 冲突
　　static 无意义(无方法体)

匿名内部类实现抽象方法：

abstract class  Animal{
    //这里使用匿名内部类实现抽象方法，就是在用的时候实现抽象方法。
    public abstract void run();

    public abstract void shout();

    public void eat(){
        System.out.println("吃东西");
    }
}


abstract class Cat extends Animal {
    public void shout(){
        System.out.println("喵喵，cat");
    };

}


public class chouxiang {
  public static void main(String[] args){
      Animal cat  = new Cat(){//匿名内部类
          public void run(){
              System.out.println("爬树");
          }
      };
      cat.shout();
      cat.run();

  }
}

 

 

接口interface:

命令特点：Inter+接口名

与主要用于扩展作用，有点像电脑的usb接口。

jdk8开始可以在接口中定义一个default修饰的实现方法

接口的特点：

A:接口用关键字interface表示
　　interface 接口名 {}
B:类实现接口用implements表示
　　class 类名 implements 接口名 {}
C:接口不能实例化
　　那么，接口如何实例化呢?
　　按照多态的方式来实例化。
D:接口的子类
　　a:可以是抽象类。但是意义不大。
　　b:可以是具体类。要重写接口中的所有抽象方法。(推荐方案)

小总结：

A:具体类多态(几乎没有)
B:抽象类多态(常用)
C:接口多态(最常用)

接口成员的特点：

接口中变量的格式：public static final xxxxx

如果你的变量没有达到这样的话，他也会给你转换成这样的。

建议按标准写，写全。

 

成员变量；只能是常量，并且是静态的。
　　默认修饰符：public static final
　　建议：自己手动给出。

构造方法：接口没有构造方法。是类自己默认继承object类

成员方法：只能是抽象方法。
　　默认修饰符：public abstract
　　建议：自己手动给出。

所有的类都默认继承自一个类：Object。

类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。

类和接口，接口和接口：

/*
    类与类：
        继承关系,只能单继承,可以多层继承。
    类与接口：
        实现关系,可以单实现,也可以多实现。
        并且还可以在继承一个类的同时实现多个接口。
    接口与接口：
        继承关系,可以单继承,也可以多继承。
*/
interface Father {
    public abstract void show();
}

interface Mother {
    public abstract void show2();
}
//继承多个接口
interface Sister extends Father,Mother {

}

//class Son implements Father,Mother //多实现
class Son extends Object implements Father,Mother {
    public void show() {
        System.out.println("show son");
    }
    
    public void show2() {
        System.out.println("show2 son");
    }
}

class InterfaceDemo3 {
    public static void main(String[] args) {
        //创建对象
        Father f = new Son();
        f.show();
        //f.show2(); //报错
    
        Mother m = new Son();
        //m.show(); //报错
        m.show2();
    }
}

抽象类和接口的区别：

抽象类和接口的区别：
A:成员区别
    抽象类：
        成员变量：可以变量，也可以常量
        构造方法：有
        成员方法：可以抽象，也可以非抽象
    接口：
        成员变量：只可以常量
        成员方法：只可以抽象
        
B:关系区别
    类与类
        继承，单继承
    类与接口
        实现，单实现，多实现
    接口与接口
        继承，单继承，多继承
        
C:设计理念区别
    抽象类 被继承体现的是：”is a”的关系。抽象类中定义的是该继承体系的共性功能。
    接口 被实现体现的是：”like a”的关系。接口中定义的是该继承体系的扩展功能。

 面向对象中的形式参数，返回值类型：

形式参数：
基本类型(太简单，不是我今天要讲解的)
引用类型
类名:(匿名对象的时候其实我们已经讲过了)需要的是该类的对象
抽象类:需要的是该抽象的类子类对象
接口:需要的是该接口的实现类对象

 

interface Love {
    public abstract void love();
}

class LoveDemo {
    public void method(Love l) { //l; l = new Teacher();  Love l = new Teacher(); 多态
        l.love();
    }
}

//定义具体类实现接口
class Teacher implements Love {
    public void love() {
        System.out.println("老师爱学生,爱Java,爱林青霞");
    }
}

class TeacherTest {
    public static void main(String[] args) {
        //需求：我要测试LoveDemo类中的love()方法
        LoveDemo ld = new LoveDemo();
        Love l = new Teacher();
        ld.method(l);
    }
}

接口，类，抽象类返回参数：

/*
    返回值类型
        基本类型:(基本类型太简单，我不准备讲解)
        引用类型：
            类:返回的是该类的对象
            抽象类:返回的是该抽象类的子类对象
            接口:返回的是该接口的实现类的对象
*/
//定义一个爱好的接口
interface Love {
    public abstract void love();
}

class LoveDemo {
    public Love getLove() {
        //Love l = new Teacher();
        //return l;
        
        return new Teacher();
    }
}

//定义具体类实现接口
class Teacher implements Love {
    public void love() {
        System.out.println("老师爱学生,爱Java,爱林青霞");
    }
}

class TeacherTest2 {
    public static void main(String[] args) {
        //如何测试呢?
        LoveDemo ld = new LoveDemo();
        Love l = ld.getLove(); //new Teacher(); Love l = new Teacher(); 多态
        l.love();
    }
}

 instanceof 关键字：

在java中可以使用instanceof关键字判断一个对象到底是那个类的实例

对象 instanceof 类   à  返回boolean类型

public class Shout {

//调用动物叫的方法,如果是兔子的化，兔子提示爱吃胡萝卜

public void call(Animal a){ // dog cat rabbit

        if(a instanceof Rabbit){//a 传的对象是Rabbit对象

               System.out.println("兔子提示爱吃胡萝卜");

        }

        //如果是猫，打印会爬树

        if(a instanceof Cat){

               System.out.println("小老虎会爬树");

        }

        a.shout();

}

}

Object类：

使用toString方法来打印类的属性

System.out.println(cat.toString());

com.zym.chouxiang$1@1b6d3586

这里他打印的结果是个内存的地址

我们需要的是属性的值，这里我们重写toString方法来实现打印属性的方法。

@Override
    public String toString() {
        //Person [age=20, name=张三]
        return "Person [age=" + age + ", name=" + name + "]";
    }

equals()方法：

一般使用自动生成的就可以，alt+insert

包装类介绍：

在Java的设计中提倡一种思想：“一切皆对象”，那么这样一来就出现了一个矛盾，从数据类型的划分中可以知道JAVA中的数据类型分为基本数据类型和引用数据类型，但是基本数据类型怎么能够称为对象呢？此时，就需要将基本数据类型进行包装，将八种基本类型变为一个类的形式，那么这也就是包装类的作用。

No.	基本数据类型	包装类
1	int	Integer
2	char	Character
3	short	Short
4	long	Long
5	float	Float
6	double	Double
7	boolean	Boolean
8	byte	Byte

 

       //基本数据类型和包装类型是自动转换的，装箱和拆箱

              int a=10;

              Integer a1=a;

              Integer in= new Integer(a);// 装箱

              int aa=in;// 拆箱

              System.out.println(aa);

装箱：

将一个基本数据类型变为包装类，这样的过程称为装箱操作

拆箱：

将一个包装类变为基本数据类型这样的过程称为拆箱操作

转换操作：

public class Test {

    public static void main(String[] args) {
        //基本数据类型和包装类型是自动转换的，封箱和拆箱
        int a=10;
        Integer a1=a;
        Integer in= new Integer(a);
        int aa=in;
        System.out.println(aa);
        //把一个字符串类型的数字，转成对应的数字
        String str1 = "123";
        str1=str1+1;
        System.out.println(str1);
        int num1 = Integer.parseInt(str1);
        num1++;
        System.out.println(num1);
        
        String str2 ="10.98";
        System.out.println(new Float(str2));
        System.out.println(Float.parseFloat(str2));
        
//        Scanner sc = new Scanner(System.in);
//        String age=sc.next();
//        User user = new User();
//        user.setAge(new Integer(age));
           
    }

}