• 面向对象二


    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));
               
        }
    
    }
  • 相关阅读:
    Oracle分页之一:最普通的分页方式
    MSSQL存储过程学习笔记一:关于存储过程
    MSSQL自动备份数据库
    小试JQuery的AutoComplete插件
    利用面向对象的方式来使用JS
    Oracle分页之三:利用PagerView来实现无刷新GridView
    由于 ASP.NET 进程标识对全局程序集缓存没有读权限,因此未能执行请求。错误: 0x80131902
    终端服务器超出最大允许连接数
    从苹果的Siri说起:云搜索与人工智能
    [转]为什么我们程序员难晋升
  • 原文地址:https://www.cnblogs.com/taozizainali/p/10712495.html
Copyright © 2020-2023  润新知