首页 / JAVA / 王志成201771010130《面向对象程序设计（java）》第八周学习总结

王志成201771010130《面向对象程序设计（java）》第八周学习总结

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了王志成201771010130《面向对象程序设计（java）》第八周学习总结，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含13626字，纯文字阅读大概需要20分钟。

内容图文

理论学习知识：

接口 ? Java为了克服单继承的缺点，Java使用了接口，一个类可以实现一个或多个接口。

? 在Java程序设计语言中，接口不是类，而是对类的一组需求描述，由常量和一组抽象方法组成。

? 接口中不包括变量和有具体实现的方法。

? 只要类实现了接口，则该类要遵从接口描述的统一格式进行定义，并且可以在任何需要该接口的地方使用这个类的对象。

接口的声明

? 声明方式： public interface 接口名 { …… } ? 接口体中包含常量定义和方法定义，接口中只进行方法的声明，不提供方法的实现

（1）通常接口的名字以able或ible结尾；（2）可以使用extends来继承接口的常量和抽象方法，扩展形成新的接口；（3）接口中的所有常量必须是public static final，方法必须是public abstract，这是系统默认的，不管你在定义接口时，写不写修饰符都是一样的。

接口的实现

? 在类声明时用implements关键字声明使用一个或多个接口 class Employee implements Printable { …… }

? 一个类使用了某个接口，那么这个类必须实现该接口的所有方法，即为这些方法提供方法体。

? 一个类可以实现多个接口，接口间应该用逗号分隔开。

class Employee implements Cloneable,Comparable

回调(callback)：一种程序设计模式，在这种模式中，可指出某个特定事件发生时程序应该采取的动作。

对象克隆

Object类的Clone方法

? Object类的clone()方法是一个native方法。

? Object类中的 clone()方法被protected修饰符修饰。这意味着在用户编写的代码中不能直接调用它。如果要直接应用clone()方法，就需覆盖clone()方法，并要把clone()方法的属性设置为 public。

? Object.clone()方法返回一个Object对象。必须进行强制类型转换才能得到需要的类型。

Lambda 表达式的语法基本结构 (arguments) -> body

1、实验目的与要求

(1) 掌握接口定义方法；

(2) 掌握实现接口类的定义要求；

(3) 掌握实现了接口类的使用要求；

(4) 掌握程序回调设计模式；

(5) 掌握Comparator接口用法；

(6) 掌握对象浅层拷贝与深层拷贝方法；

(7) 掌握Lambda表达式语法；

(8) 了解内部类的用途及语法要求。

2、实验内容和步骤

实验1：导入第6章示例程序，测试程序并进行代码注释。

测试程序1：

l 编辑、编译、调试运行阅读教材214页-215页程序6-1、6-2，理解程序并分析程序运行结果；

l 在程序中相关代码处添加新知识的注释。

l 掌握接口的实现用法；

l 掌握内置接口Compareable的用法。

            public
            class Employee implements Comparable<Employee>
{
   private String name;
   privatedouble salary;

   public Employee(String name, double salary)
   {
      this.name = name;
      this.salary = salary;
   }

   public String getName()
   {
      return name;
   }

   publicdouble getSalary()
   {
      return salary;
   }

   publicvoid raiseSalary(double byPercent)
   {
      double raise = salary * byPercent / 100;
      salary += raise;
   }

   /**
      * 以工资比较雇员  
    * @param另一个Employee对象
     * 如果该员工的工资低于otherObject，如果工资相同，则为0，否则为正值 
    */publicint compareTo(Employee other)
   {
      return Double.compare(salary, other.salary);
   }
}

            import java.util.*;

publicclass EmployeeSortTest
{
   publicstaticvoid main(String[] args)
   {
      Employee[] staff = new Employee[3];

      staff[0] = new Employee("Harry Hacker", 35000);
      staff[1] = new Employee("Carl Cracker", 75000);
      staff[2] = new Employee("Tony Tester", 38000);

      Arrays.sort(staff);
 
    //打印所有Employee对象的信息for (Employee e : staff)
         System.out.println("name=" + e.getName() + ",salary=" + e.getSalary());
   }
}

技术分享图片

测试程序2：

l 编辑、编译、调试以下程序，结合程序运行结果理解程序；

            package
             实验8;

            interface
              A
{
  
            double g=9.8;
  void show( );
}
class C implements A
{
  publicvoid show( )
  {System.out.println("g="+g);}
}

 class  OO
{
  publicstaticvoid main(String[ ] args)
  {
       A a=new C( );
       a.show( );
       System.out.println("g="+C.g);
  }
}

技术分享图片

测试程序3：

l 在elipse IDE中调试运行教材223页6-3，结合程序运行结果理解程序；

l 26行、36行代码参阅224页，详细内容涉及教材12章。

l 在程序中相关代码处添加新知识的注释。

l 掌握回调程序设计模式；

            import java.awt.*;
import java.awt.event.*;
import java.util.*;
import javax.swing.*;
import javax.swing.Timer; 
// 解决与java.util.Timer的冲突publicclass TimerTest
{  
   publicstaticvoid main(String[] args)
   {  
      ActionListener listener = new TimePrinter();

      // 构造一个调用侦听器的计时器
      // 每10秒一次
      Timer t = new Timer(10000, listener);
      t.start();

      JOptionPane.showMessageDialog(null, "Quit program?");
      System.exit(0);
   }
}

class TimePrinter implements ActionListener
{  
   publicvoid actionPerformed(ActionEvent event)
   {  
      System.out.println("At the tone, the time is " + new Date());
      Toolkit.getDefaultToolkit().beep();
   }
}

结果：

技术分享图片

测试程序4：

l 调试运行教材229页-231页程序6-4、6-5，结合程序运行结果理解程序；

l 在程序中相关代码处添加新知识的注释。

l 掌握对象克隆实现技术；

l 掌握浅拷贝和深拷贝的差别。

            package
             clone;


            /**
            
 * This program demonstrates cloning.
 * 
            @version
             1.10 2002-07-01
 * 
            @author
             Cay Horstmann
 
            */
            public
            class
             CloneTest
{
   
            public
            static
            void
             main(String[] args)
   {
      
            try
            
      {
        
         Employee original = new Employee("John Q. Public", 50000);
         //Employee是一个自定义类
         original.setHireDay(2000, 1, 1);
         Employee copy = original.clone();
         copy.raiseSalary(10);//原有对象不会发生变化
         copy.setHireDay(2002, 12, 31);//更改器
         System.out.println("original=" + original);//字符串连接
         System.out.println("copy=" + copy);
      }
      catch (CloneNotSupportedException e)
      {
         e.printStackTrace();
      }
   }
}

            package
             clone;


            import
             java.util.Date;

            import
             java.util.GregorianCalendar;


            public
            class Employee implements Cloneable//实现Cloneable接口{
   private String name;
   privatedouble salary;
   private Date hireDay;

   public Employee(String name, double salary)
   {
      this.name = name;
      this.salary = salary;
      hireDay = new Date();
   }

   public Employee clone() throws CloneNotSupportedException//定义一个克隆方法   {
      // 调用 Object.clone()
      Employee cloned = (Employee) super.clone();// 继承object类

      // 克隆可变的字段
      cloned.hireDay = (Date) hireDay.clone();
      //cloned.name=(String)name.clone();String不具有克隆功能；return cloned;
   }

   /**
    * Set the hire day to a given date. 
    * @param year the year of the hire day
    * @param month the month of the hire day
    * @param day the day of the hire day
    */publicvoid setHireDay(int year, int month, int day)
   {
      Date newHireDay = new GregorianCalendar(year, month - 1, day).getTime();
      
      // 实例字段突变的例子      hireDay.setTime(newHireDay.getTime());
   }

   publicvoid raiseSalary(double byPercent)
   {
      double raise = salary * byPercent / 100;
      salary += raise;
   }

   public String toString()
   {
      return "Employee[name=" + name + ",salary=" + salary + ",hireDay=" + hireDay + "]";
   }
}

技术分享图片

实验2：导入第6章示例程序6-6，学习Lambda表达式用法。

l 调试运行教材233页-234页程序6-6，结合程序运行结果理解程序；

l 在程序中相关代码处添加新知识的注释。

l 将27-29行代码与教材223页程序对比，将27-29行代码与此程序对比，体会Lambda表达式的优点。

            package
             lambda;


            import java.util.*;

import javax.swing.*;
import javax.swing.Timer;publicclass LambdaTest
{
   publicstaticvoid main(String[] args)
   {
      String[] planets = new String[] { "Mercury", "Venus", "Earth", "Mars", 
            "Jupiter", "Saturn", "Uranus", "Neptune" };
      System.out.println(Arrays.toString(planets));
      System.out.println("Sorted in dictionary order:");
      Arrays.sort(planets);
      System.out.println(Arrays.toString(planets));
      System.out.println("Sorted by length:");
      Arrays.sort(planets, (first, second) -> first.length() - second.length());
      System.out.println(Arrays.toString(planets));
            
      Timer t = new Timer(1000, event ->
         System.out.println("The time is " + new Date()));
      //event ->System.out.println("The time is " + new Date()));lambda表达式；      t.start();   
         
      // 保持程序运行，直到用户选择“Ok”
      JOptionPane.showMessageDialog(null, "Quit program?");
      System.exit(0);         
   }
}

技术分享图片

注：以下实验课后完成

实验3: 编程练习

l 编制一个程序，将身份证号.txt 中的信息读入到内存中；

l 按姓名字典序输出人员信息；

l 查询最大年龄的人员信息；

l 查询最小年龄人员信息；

l 输入你的年龄，查询身份证号.txt中年龄与你最近人的姓名、身份证号、年龄、性别和出生地；

l 查询人员中是否有你的同乡。

            import
             java.io.BufferedReader;

            import
             java.io.File;

            import
             java.io.FileInputStream;

            import
             java.io.FileNotFoundException;

            import
             java.io.IOException;

            import
             java.io.InputStreamReader;

            import
             java.util.ArrayList;

            import
             java.util.Arrays;

            import
             java.util.Collections;

            import
             java.util.Scanner;


            public
            class
             main{
    
            private
            static ArrayList<person> Personlist;
    publicstaticvoid main(String[] args) {
        Personlist = new ArrayList<>();
        Scanner scanner = new Scanner(System.in);
        File file = new File("D:\\身份证号.txt");
        try {
            FileInputStream fis = new FileInputStream(file);
            BufferedReader in = new BufferedReader(new InputStreamReader(fis));
            String temp = null;
            while ((temp = in.readLine()) != null) {
                
                Scanner linescanner = new Scanner(temp);
                
                linescanner.useDelimiter(" ");    
                String name = linescanner.next();
                String ID = linescanner.next();
                String sex = linescanner.next();
                String age = linescanner.next();
                String place =linescanner.nextLine();
                person Person = new person();
                Person.setname(name);
                Person.setID(ID);
                Person.setsex(sex);
                int a = Integer.parseInt(age);
                Person.setage(a);
                Person.setbirthplace(place);
                Personlist.add(Person);

            }
        } catch (FileNotFoundException e) {
            System.out.println("查找不到信息");
            e.printStackTrace();
        } catch (IOException e) {
            System.out.println("信息读取有误");
            e.printStackTrace();
        }
        boolean isTrue = true;
        while (isTrue) {
            System.out.println("1:按姓名字典序输出人员信息");
            System.out.println("2:查询最大年龄与最小年龄人员信息");
            System.out.println("3：输入你的年龄，查询与你最近人的姓名、身份证号、年龄、性别和出生地；");
            System.out.println("4:查询是否有同乡");
            System.out.println("5：退出");
            int nextInt = scanner.nextInt();
            switch (nextInt) {
            case 1:
                Collections.sort(Personlist);
                System.out.println(Personlist.toString());
                break;
            case 2:
                
                int max=0,min=100;int j,k1 = 0,k2=0;
                for(int i=1;i<Personlist.size();i++)
                {
                    j=Personlist.get(i).getage();
                   if(j>max)
                   {
                       max=j; 
                       k1=i;
                   }
                   if(j<min)
                   {
                       min=j; 
                       k2=i;
                   }

                }  
                System.out.println("年龄最大："+Personlist.get(k1));
                System.out.println("年龄最小："+Personlist.get(k2));
                break;
            case 3:
                System.out.println("年龄：");
                int yourage = scanner.nextInt();
                int near=agenear(yourage);
                int d=yourage-Personlist.get(near).getage();
                System.out.println(""+Personlist.get(near));
                break;
            case 4:
                System.out.println("你的家乡?");
                String find = scanner.next();        
                String place=find.substring(0,3);
                String place2=find.substring(0,3);
                for (int i = 0; i <Personlist.size(); i++) 
                {
                    if(Personlist.get(i).getbirthplace().substring(1,4).equals(place)) 
                        System.out.println(""+Personlist.get(i));

                } 

                break;
            case 5:
           isTrue = false;
           System.out.println("退出程序!");
                break;
            default:
                System.out.println("输入有误");
            }
        }
    }
    publicstaticint agenear(int age) {
     
       int j=0,min=53,d=0,k=0;
        for (int i = 0; i < Personlist.size(); i++)
        {
            d=Personlist.get(i).getage()-age;
            if(d<0) d=-d; 
            if (d<min) 
            {
               min=d;
               k=i;
            }

         }    return k;
        
     }

 
}

            public
            class person implements Comparable<person> {
private String name;
private String ID;
privateint age;
private String sex;
private String birthplace;

public String getname() {
return name;
}
publicvoid setname(String name) {
this.name = name;
}
public String getID() {
return ID;
}
publicvoid setID(String ID) {
this.ID= ID;
}
publicint getage() {

return age;
}
publicvoid setage(int age) {
    // int a = Integer.parseInt(age);this.age= age;
}
public String getsex() {
return sex;
}
publicvoid setsex(String sex) {
this.sex= sex;
}
public String getbirthplace() {
return birthplace;
}
publicvoid setbirthplace(String birthplace) {
this.birthplace= birthplace;
}

publicint compareTo(person o) {
   returnthis.name.compareTo(o.getname());

}

public String toString() {
    return  name+"\t"+sex+"\t"+age+"\t"+ID+"\t"+birthplace+"\n";

}



}

技术分享图片

实验4：内部类语法验证实验

实验程序1：

l 编辑、调试运行教材246页-247页程序6-7，结合程序运行结果理解程序；

l 了解内部类的基本用法。

            package
             innerClass;


            import java.awt.*;
import java.awt.event.*;
import java.util.*;
import javax.swing.*;
import javax.swing.Timer;
publicclass InnerClassTest
{
   publicstaticvoid main(String[] args)
   {
      TalkingClock clock = new TalkingClock(1000, true);
      clock.start();

      // 保持程序运行，直到用户选择“Ok”
      JOptionPane.showMessageDialog(null, "Quit program?");
      System.exit(0);
   }
}

/**
 *一种定时打印时间的时钟。
 */class TalkingClock
{
   privateint interval;
   privateboolean beep;

   /**
    * Constructs a talking clock
    * @param interval the interval between messages (in milliseconds)
    * @param beep true if the clock should beep
    */public TalkingClock(int interval, boolean beep)
   {
      this.interval = interval;
      this.beep = beep;
   }

   /**
    * Starts the clock.
    */publicvoid start()
   {
      ActionListener listener = new TimePrinter();
      Timer t = new Timer(interval, listener);
      t.start();
   }

   publicclass TimePrinter implements ActionListener
   {
      publicvoid actionPerformed(ActionEvent event)
      {
         System.out.println("At the tone, the time is " + new Date());
         if (beep) Toolkit.getDefaultToolkit().beep();
      }
   }
}

技术分享图片

实验程序2：

l 编辑、调试运行教材254页程序6-8，结合程序运行结果理解程序；

l 了解匿名内部类的用法。

            package
             anonymousInnerClass;


            import java.awt.*;
import java.awt.event.*;
import java.util.*;
import javax.swing.*;
import javax.swing.Timer;

/**
 * This program demonstrates anonymous inner classes.
 * @version 1.11 2015-05-12
 * @author Cay Horstmann
 */publicclass AnonymousInnerClassTest
{
   publicstaticvoid main(String[] args)
   {
      TalkingClock clock = new TalkingClock();
      clock.start(1000, true);

      // keep program running until user selects "Ok"
      JOptionPane.showMessageDialog(null, "Quit program?");
      System.exit(0);
   }
}

/**
 * A clock that prints the time in regular intervals.
 */class TalkingClock
{
   /**
    * Starts the clock.
    * @param interval the interval between messages (in milliseconds)
    * @param beep true if the clock should beep
    */publicvoid start(int interval, boolean beep)
   {
      ActionListener listener = new ActionListener()
         {
            publicvoid actionPerformed(ActionEvent event)
            {
               System.out.println("At the tone, the time is " + new Date());
               if (beep) Toolkit.getDefaultToolkit().beep();
            }
         };
      Timer t = new Timer(interval, listener);
      t.start();
   }
}

技术分享图片

实验程序3：

l 在elipse IDE中调试运行教材257页-258页程序6-9，结合程序运行结果理解程序；

l 了解静态内部类的用法。

            package
             staticInnerClass;


            public
            class
             StaticInnerClassTest
{
   
            public
            static
            void
             main(String[] args)
   {
      
            double[] d = newdouble[20];
      for (int i = 0; i < d.length; i++)
         d[i] = 100 * Math.random();
      ArrayAlg.Pair p = ArrayAlg.minmax(d);
      System.out.println("min = " + p.getFirst());
      System.out.println("max = " + p.getSecond());
   }
}

class ArrayAlg
{
   /**
    * A pair of floating-point numbers
    */publicstaticclass Pair
   {
      privatedouble first;
      privatedouble second;

      /**
       * Constructs a pair from two floating-point numbers
       * @param f the first number
       * @param s the second number
       */public Pair(double f, double s)
      {
         first = f;
         second = s;
      }

      /**
       * Returns the first number of the pair
       * @return the first number
       */publicdouble getFirst()
      {
         return first;
      }

      /**
       * Returns the second number of the pair
       * @return the second number
       */publicdouble getSecond()
      {
         return second;
      }
   }

   /**
    * Computes both the minimum and the maximum of an array
    * @param values an array of floating-point numbers
    * @return a pair whose first element is the minimum and whose second element
    * is the maximum
    */publicstatic Pair minmax(double[] values)
   {
      double min = Double.POSITIVE_INFINITY;
      double max = Double.NEGATIVE_INFINITY;
      for (double v : values)
      {
         if (min > v) min = v;
         if (max < v) max = v;
      }
      returnnew Pair(min, max);
   }
}

技术分享图片

总结：这一周主要学习了接口的主要知识，其中主要进行了克隆和回调知识的学习以及lambda表达式的学习。一个类可以实现一个会多个接口，并在需要接口的地方，随时使用实现了相应接口的对象，这项技术使得程序设计技术更加全面，也是我们需要掌握的主要知识，但我承认我掌握的还不好，但我会继续努力，同时也感谢老师和助教的辛勤付出，给我们很大的帮助，尽管现在我面临的问题还有很多，但我相信我可以将这些问题一一解决。

原文：https://www.cnblogs.com/847118824wang/p/9821530.html

内容总结

以上是互联网集市为您收集整理的王志成201771010130《面向对象程序设计（java）》第八周学习总结全部内容，希望文章能够帮你解决王志成201771010130《面向对象程序设计（java）》第八周学习总结所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1184902.html

来源：【匿名】

【上一篇】java基础总结（六）【集合】【下一篇】JAVA/JSP学习系列之五

更多 ►

【王志成201771010130《面向对象程序设计（java）》第八周学习总结】教程文章相关的互联网学习教程文章

java面向对象小总结【图】

类：类就是对某一事物的描述（举例：蔬菜，水果，动物）对象：对象就是实际存在的事物的个体，（举例：蔬菜中某一种，人类（分男人和女人））标准类：【类的修饰字】 class 类名称【extends 父类名称】【implements 接口名称列表】{变量定义及初始化；成员变量；方法定义及初始化；成员方法；}记住：继承只能继承一个类，可以实现多个接口，static：静态方法，又称为类方法，static声明的变量值，所有对象使用...

Javascript高级程序设计——面向对象之实现继承【代码】

原型链：　　构造函数中都有一个prototype属性指针，这个指针指向原型对象，而创建的实例也有指向这个原型对象的指针__proto__。当实例查找方法时先在实例上找，找不到再通过__proto__到原型对象上查找。如果原型对象是另一个类型的实例，那么原型对象包含一个指向另一个原型对象的指针、另一个原型对象中也包含指向另一个构造函数的指针。原型连继承function superValue(){this.superValue = "superValue"; }superValue.prototype...

java面向对象的核心思想【代码】

Java面向对象-抽象类与接口1.Java final关键字的使用package edu.tongji.fni;/*final关键字* 1、final关键字在java中被称为完结器，表示最终的意思* 2、final能声明类、方法、属性：* 使用final声明的类不能被继承* 使用final声明的方法不能被重写* 使用final声明的变量变成常量，常量是不可以被修改的 */class People{ //前面加了final下面的类会报错public void tell(){} }class Student extends People{public void tell(){} }...

Java面向对象程序设计【图】

北京电子科技学院（BESTI）实验报告课程：Java 班级：1352 姓名：马悦学号：20135235 成绩：指导教师：娄嘉鹏实验日期：2015.05.07 ...

java面向对象（封装）【代码】

一.封装的概述封装是指一种将抽象性函式接口的实现细节部份包装、隐藏起来的方法。是面向对象思想的特征之一，面向对象共有三个特征：封装，继承，多态。二.封装的优点1.良好的封装能够减少耦合。2. 类内部的结构可以自由修改。3. 可以对成员变量进行更精确的控制。4. 隐藏信息，实现细节。三.封装举例（步骤）1. 修改属性的可见性来限制对属性的访问（一般限制为private） publicclass Person {private String name;privateint ag...

【Java】面向对象之多态【代码】

生活中，比如动物中跑的动作，小猫、小狗和大象，跑起来是不一样的。再比如飞的动作，昆虫、鸟类和飞机，飞起来也是不一样的。可见，同一类的事物通过不同的实际对象可以体现出来的不同的形态。多态，描述的就是这样的状态。多态：是指同一行为，具有多个不同表现形式。具备多态的前提：（1）具备继承或者实现【二选一】；（2）方法的重写【不重写，无意义】；（3）父类引用指向子类对象【格式体现】。多态的体现多态体现的格式：...

20135234马启扬实验二 Java面向对象程序设计【图】

北京电子科技学院（BESTI）　　　　　　　　　　　　　　　　　　　　　　　　　　　　实验报告　　　　　　　　　　　　　　　　　　课程：Java程序设计班级：1352 姓名：马启扬学号：20135234　　　　　　　　　　　　　　　　　　成绩：指导教师：娄嘉鹏实验日期：2015.5.7　　　　　　　　　　　　　　　　　　实验密级：预习程度：实验时间：15:50--22:50　　　　　　...

面向对象的延伸与Java内部定义类的应用【代码】

识别类传统的过程化程序设计,必须从顶部的main函数开始编写程序,在面向对象程序设计时没有所谓的"顶部".首先从设计类开始,然后再往每个类中添加方法.识别类的规则是在分析问题的过程中寻找名词,而方法对应着动词.例如在订单处理系统中,有这样一些名词: 商品(Item)订单(Order)送货地址(Shopping address)付款(Payment)账户(Account)接下来,查看动词:商品被添加到订单中,订单被发送或取消,对于每一个动词如:"添加","发送","取消",都要...

javascript 面向对象OOP笔记【代码】

<!DOCTYPE html> <html lang="en"> <head><meta charset="UTF-8"><title>OOP</title><script type="text/javascript">function myOOP() {alert(this.a);alert(this.b);}var a = 12;window.b = 2;window.onload = function(){var c = [1,2,3,4,5,6];var d = 7;c.e = 8;c.f = function () {alert(this.e);};c.f();this.myOOP();window.myOOP();myOOP();};</script> </head> <body> </body> </html> 原文：http://www.cnblogs.com/fen...

JavaScript设计模式：一、面向对象编程（第三节）【代码】

一、继承 js并没有继承这一个现有的机制，所以我们所说的继承是通过JS本身的机制去实现的。1、类式继承 1// 类式继承 2 3// 父类 4function SuperClass () {5this.superValue = true 6}7 8// 为父类原型添加方法 9 SuperClass.prototype.getSuperValue = function (arguments) { 10returnthis.superValue 11} 1213// 声明子类14function SubClass () { 15this.subValue = false16} 1718// 继承父类19 SubClass.prototype = new S...

javascript-面向对象【代码】【图】

万物皆对象（づ￣3￣）づ╭?～面向对象的基本概念：类和实例。JavaScript不区分类和实例，通过原型来实现面向对象。1. 类--->原型对象JavaScript是一种直译式脚本语言，是一种动态类型、弱类型、基于原型的语言，内置支持类型。这种动态语言，是指程序在运行时可以改变其结构：新的函数可以被引进，已有的函数可以被删除等在结构上的变化。本身不提供class实现（在ES2015/ES6中引入class关键字，但只是语法糖，JavaScript仍然是基...

java面向对象编程(1)-类与对象【代码】

1.问题的提出张老太养了两只猫猫：一只名字叫小白，今年3岁，白色。还有一只叫小花，今年100岁，花色。请编写一个程序，当用户输入小猫的名字时，就显示该猫的名字，年龄，颜色。如果用户输入的小猫名错误，则显示张老太没有这只猫。 //用前面学习过的知识写出代码如下：publicclass Demo107{publicstaticvoid main(String []args){int a=49;//输入的名字49，50int cat1age=3; //第一只猫String cat1name="小白";String cat...

Java学习之面向对象三【代码】

1、多态是什么，多态的前提条件是什么? 多态就是父类引用变量指向子类对象；前提条件：必须有子父类关系或类实现接口关系；2、多态中成员访问的特点分别是什么? 成员变量：当子父类中出现同名的成员变量，多态调用该变量时，编译时期：参考的是引用变量所属的类中是否有被调用的成员变量。没有编译失败；运行时期：也是调用引用型变量所属的类中的成员变量；简单记：运行编译看左边。　成...