• 【代码笔记】Java基础:Java的方法和类


    1. 面向过程与面向对象都是我们编程中,编写程序的一种思维方式。例如:公司打扫卫生(擦玻璃、扫地、拖地、倒垃圾等),

      按照面向过程的程序设计方式会思考“打扫卫生我该怎么做,然后一件件的完成”,最后把公司卫生打扫干净了。

    按照面向对象的程序设计方式会思考“我该让谁来做,如小明擦玻璃、让小丽扫地、让小郭拖地、让小强倒垃圾等”,这里的“小明、小丽、小郭、小强”就是对象,他们要打扫卫生,怎么打扫是他们自己的事,反正最后一群对象合力把公司卫生打扫干净了。

    继续举例:

    使用面向过程说明买电脑这件事:分析整个过程大体分一下几步:上网查询参数和报价、电脑城询价、现场安装和监督、抱电脑回家。在整个过程中我们参与了每一个细节,并且会感觉相当累。

    使用面向对象说明买电脑这件事:只要找到懂电脑硬件的这个人,我们的问题都可以解决。并且在这个过程中我们不用那么辛苦。

    所以,面向过程思维方式中更多的体现的是执行者(自己做事情),面向对象中更多的体现是指挥者(指挥对象做事情)。

    1. Java作为一种面向对象的语言,具备三大特性(面向对象的核心):封装性   继承性   多态性
      1. 封装性:就是打包,所有东西都是打包好的。
      2. 继承:子类可以继承父类
        • 文件名:Student.java
        • 1 public class Student {
          2     public String name;
          3     public int age;
          4     
          5     public void study(){
          6         System.out.println("学生学习");
          7     }
          8 }
          文件名:Unstudent.java
          • 在上文中定义了普通方法学生(Student),并定义一个普通行为——普通类学习(study)
          • Student作为构造函数,构造函数是不能被继承,所以也不存在构造函数重写
        • 1 public class UnStudent extends Student{
          2     public void study(){
          3         System.out.println("大学生的学习方法");
          4     }
          5     public void playGame(){
          6         System.out.println("大学生玩dota");
          7     }
          8 }
          文件名:Test.java
          • 在上文中定义了普通方法大学生(Unstudent),并继承(extends)普通方法学生(Study)
          • 同时,它在子类(Unstudent),继承父类(Study)的前提,子类定义一个和父类相同的(方法名、参数、返回类型)方法(“public void study(){
            ”)。
          • 子类可以定义新的行为(类)“playGame”。
        •  1 public class Test {
           2     public static void main(String[] args) {    
           3         //自动转型
           4         UnStudent us = new UnStudent();
           5         Student us1 = new UnStudent();
           6         Student us2 = new Student();
           7         
           8         us.study();
           9         us1.study();
          10         us2.study();
          11         
          12         us.playGame();
          13         us1.playGame();
          14         us2.playGame();
          15     }
          16 }
          • 在上文中主函数里大学生(Unstudent)“ us ”构造一次,进行方法重载。“ us ”将具备普通方法UnStudent所有特性,并且进行方法重写的将覆盖父类原有的类的定义。
          • “ us1 ”具备Student所有属性,但被UnStudent重写的属性将会是UnStudent重写后的内容,原Student内类将会被覆盖,UnStudent内存在但Student不存在的类“ us1 ”将无法调用。
          • “ us2 ” 就是正宗Student类。
        1. 上面存在两种方法:
          • 自动转型
            定义:创建子类的对象,然后自动转型为父类的类型
            格式:父类类名  对象名  = new  子类类名();
          • 转型后的对象类型为转型后的类型,执行的方法如果子类重写了父类的方法,则执行的是重写后的,如果没有重写,则执行的是父类自己的
            如果没有自动转型过程,则执行的方法都是自己的方法
      3. 因为存在自动转型和方法重写和继承等特性,所以Java语言呈现多态性。
        1. 多个同一种类型的对象,执行同一个方法,执行的过程不一样(有区别)
        2. 为什么会有多态现象???
          • 自动转型+方法重写    
          • 自动转型+方法重写  将导致具有继承性,因此将具备多态性
    2. Java语言的方法分类只有三种:
      1. 构造方法:public 类名( ){ }
      2. 普通方法:public 返回类型  方法名(参数){ }
      3. 抽象方法:public abstract 返回类型 方法名(参数);
    3. Java语言类的分类也有三种:
      1. 普通类:public class 类名{}
        1. 只能有普通方法和构造方法,一定不能有抽象方法
        2. 可以创建对象
        3. 属性可以是常量(static final),也可以是变量
      2. 抽象类:public abstract class 类名{}
        1. 三种类型的方法都可以存在
        2. 不能创建对象
        3. 属性可以是常量(static final),也可以是变量
      3. 接口:public interface 类名(){}
        1. 只能有抽象方法,普通方法和构造方法不存在
        2. 不能创建对象
        3. 属性一定是常量(static final)
    4. 接口和抽象类有什么用?文件名:Teacher.java
      1. 接口和抽象类的作用是用来当父类被继承的,抽象方法是用来指导子类重写(实现)的
      2. 关键子:implements
      3. 格式:
        • public class 子类类名  implements 接口名{
            //重写父类的所有的抽象方法
           }
      4. 接口无非就是领导,只是指导开发
    5.  1 public interface Teacher {
       2     public static final String name = "aa";
       3     public static final String job = "aa";
       4     public static final int age = 20;
       5     
       6     //抽象方法
       7     public abstract void play1();
       8     public abstract void play2();
       9     public abstract void play3();
      10     public abstract void play4();
      11     public abstract void play5();
      12 }
    6. 文件名:UnTeacehr.java
      1 public abstract class UnTeacher implements Teacher{
      2     
      3 }
      1. 在上文两个文件中“ Teacher ”类作为接口类(关键词  interface 表示接口类
      2. 具备三个常量,不可更改。
      3. 有抽象方法,无法实现和定义。

     7.多态

    父类引用变量可以指向子类对象。

    多态的前提是必须有子父类关系或者类实现接口关系,否则无法完成多态。

    在使用多态后的父类引用变量调用方法时,会调用子类重写后的方法。

     

    可以理解为:

    有人找孔子他爹去给人上课,

    到孔子家里发现他爹不在家,

    孔子说,我化妆成我爹的样子,

    去给人家上课行不行,

    孔子不会他爹的课程,

    他只会讲论语。

    行,那本来找你爹的,那你就讲论语吧。

     

    8.instanceof关键词

    我们可以通过instanceof关键字来判断某个对象是否属于某种数据类型。如学生的对象属于学生类,学生的对象也属于人类。

    在多态的情况下,因为会将父类声明为子类,当程序复杂度增加到一定量时,往往分不清,声明的是什么子类,而instanceof关键词可以帮助我们判断,基本格式举例为:

    Person p = new Teacher();//多态

    boolean trueorfalse = p instanceof Student;

    这时返回的trueorfalse值为false。

     这个例子也叫“向上转型”,子类提升为了父类类型。

    可以调用子类和父类的共有类型,但不能调用子类的特有成员。

     

    还有向下转型

    由父类类型强制转为子类类型,举例格式:

    Fu f = new ErZi();

     ErZi z = ( ErZi)f;

    好处:可以调用子类特有得1功能。

     

    可以理解为:

    孔子还喜欢打游戏,

    孔子爹不会,打游戏不好。

    但孔子爹还是觉得陪孩子打游戏可以正确引导他。

    但是他不会,

    孔子爹强行抓起游戏手柄一顿瞎按。

    坑是一回事,也能玩嘛。

     9.0 this的第二种用法

    package cn.itcast.demo03;
    /*
     *   this可以在构造方法之间进行调用
     *   this.的方式,区分局部变量和成员变量同名情况
     *   this在构造方法之间的调用,语法 this()
     */
    public class Person {
        private String name;
        private int age;
        
        public Person(){
            //调用了有参数的构造方法
            //参数李四,20传递给了变量name,age
            this("李四",20);
        }
        /*
         *  构造方法,传递String,int
         *  在创建对象的同时为成员变量赋值
         */
        public Person(String name,int age){
            this.name = name;
            this.age = age;
        }
        
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
        
        
    }

     

    10.0 super的用法,具体看代码:

    //定义Person类,将Student和Worker共性抽取出来
    class Person {
        private String name;
        private int age;
        public Person(String name, int age) {
            // super();
            this.name = name;
            this.age = age;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
    }
    class Student extends Person {
        // Student类的构造方法
        Student(String name, int age) {
            // 使用super关键字调用父类构造方法,进行相应的初始化动作
            super(name, age);
        }
        public void study() {// Studnet中特有的方法
            System.out.println(this.getName() + "同学在学习");
        }
    }
    class Worker extends Person {
        Worker(String name, int age) {
            // 使用super关键字调用父类构造方法,进行相应的初始化动作
            super(name, age);
        }
        public void work() {// Worker 中特有的方法
            System.out.println(this.getName() + "工人在工作");
        }
    }
    public class Test {
        public static void main(String[] args) {
            Student stu = new Student("小明",23);
    stu.study();
            
    Worker w = new Worker("小李",45);
    w.work();
        }
    }

     

     

     

     

     

     

  • 相关阅读:
    约数
    质数
    回炉重造之重读Windows核心编程-018-堆栈
    回炉重造之重读Windows核心编程-017- 内存映射文件
    换电脑遇到git的一些记录
    python3之迭代器和生成器
    python3之类和对象
    python3之错误和异常
    python3之函数
    python3之流程控制
  • 原文地址:https://www.cnblogs.com/xiaofu007/p/5245203.html
Copyright © 2020-2023  润新知