类的定义、类的继承、多态、样例类

已于 2022-05-03 20:44:08 修改
阅读量712 收藏
点赞数
分类专栏： Scala基础 初学大数据 文章标签： Scala
于 2022-05-03 20:04:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZZJXP/article/details/124555755
版权 
/**
 * Java中的类
 * 可以在类中定义属性、方法
 */
public class Demo02StudentJava {
    String id;
    String name;
    int age;
    String clazz;

    //构造方法 对属性进行初始化
    //无参构造方法
    public Demo02StudentJava(){

    }

    //重载构造方法
    public Demo02StudentJava(String id,String name,int age){
        this.id=id;
        this.name=name;
        this.age=age;
        this.clazz="自由分班";
    }

    //重载构造方法
    public Demo02StudentJava(String id,String name,int age,String clazz){
        this.id=id;
        this.name=name;
        this.age=age;
        this.clazz=clazz;
    }

    @Override
    //重写父类的构造方法
    public String toString() {
        return "Demo02StudentJava{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public void printClazz(){
        System.out.println(this.name+","+this.clazz);
    }

    public static void main(String[] args) {
       //传入参数 创建对象 该对象会默认获得类中定义的属性和方法
        Demo02StudentJava stu1 = new Demo02StudentJava();
        Demo02StudentJava zs = new Demo02StudentJava("001", "zs", 20);
        System.out.println(stu1);
        System.out.println(zs);

        Demo02StudentJava ls = new Demo02StudentJava("002", "ls", 21);
        Demo02StudentJava ww = new Demo02StudentJava("003", "ww", 22,"文科一班");

        ls.printClazz();
        ww.printClazz();
    }
}

Demo02StudentJava{id='null', name='null', age=0}
Demo02StudentJava{id='001', name='zs', age=20}
ls,自由分班
ww,文科一班

/**
 * Scala中的类
 * 面向对象：封装 继承 多态
 * 也可以定义属性、方法
 * {}默认的构造方法
 */
class Demo03StudentScala(id:String,name:String,age:Int) {
  //定义属性即赋值
  val _id:String=id
  val _name:String=name
  val _age:Int=age
  var _clazz:String=_  //待会再赋值
//  var _clazz:String="自由分班" //给默认值


  //重载构造方法
  def this(id:String,name:String,age:Int,clazz:String){
    //第一行代码必须调用默认的构造方法
    this(id,name,age)
    println("重载构造方法")

    this._clazz=clazz
  }

  override def toString(): String ={
    return s"Demo03StudentScala(id=${_id},name=${_name},age=${_age})"
  }

  def printStuName():Unit={
    println(_name)
  }

  def  printClazz(): Unit ={
    println(this._clazz)
  }
}

object Demo03StudentScala{
  def main(args: Array[String]): Unit = {
    //创建对象
    val zs: Demo03StudentScala = new Demo03StudentScala("001", "zs", 20)
    val ls: Demo03StudentScala = new Demo03StudentScala("002", "ls", 21)
    println(zs)
    println(ls)
    println(zs._name)

    zs.printStuName()
    ls.printStuName()

    val ww: Demo03StudentScala = new Demo03StudentScala("003", "ww", 22)
    val xm: Demo03StudentScala = new Demo03StudentScala("004", "xm", 23,"文科二班")
    ww.printClazz()
    xm.printClazz()
  }
}

 Demo03StudentScala(id=001,name=zs,age=20)
Demo03StudentScala(id=002,name=ls,age=21)
zs
zs
ls
重载构造方法
null
文科二班

class Person(id:String,name:String,age:Int) {
  val _id:String=id
  val _name:String=name
  val _age:Int=age

  def printName(): Unit ={
    println(s"这是Person类中的对象，名字为$name")
  }

  def walk(): Unit ={
    println("人类会行走")
  }
}

class Teacher(id:String,name:String,age:Int,clazz:String) {
  val _id: String = id
  val _name: String = name
  val _age: Int = age
  val _clazz: String = clazz

  def printName(): Unit = {
    println(s"这是Teacher类中的对象，名字为$name")
  }

  def walk(): Unit ={
    println("Teacher也属于Person,也会行走")
  }
}

class Student(id:String,name:String,age:Int,gender:String,clazz:String) {
  val _id: String = id
  val _name: String = name
  val _age: Int = age
  val _gender:String=gender
  val _clazz: String = clazz

  def printName(): Unit = {
    println(s"这是Student类中的对象，名字为$name")
  }

  def walk(): Unit ={
    println("Student也属于Person,也会行走")
  }
}
class Person(id:String,name:String,age:Int) {
  val _id:String=id
  val _name:String=name
  val _age:Int=age

  def printName(): Unit ={
    println(s"这是Person类中的对象，名字为$name")
  }

  def walk(): Unit ={
    println("人类会行走")
  }

  override def toString: String ={
    return s"Person(${_id},${_name},${_age})"
  }
}

//Scala在继承父类时，需要调用父类的构造方法
class Teacher(id:String,name:String,age:Int,clazz:String) extends Person(id,name,age) {
  //对子类特有的属性做初始化
  val _clazz: String = clazz

  //父类中由同名的方法 需要加上override进行重写
  override def printName(): Unit = {
    println(s"这是Teacher类中的对象，名字为$name")
  }

  override def walk(): Unit ={
    println("Teacher也属于Person,也会行走")
  }

  override def toString: String ={
    return s"Teacher(${_id},${_name},${_age},${_clazz})"
  }
}

//继承能够获得父类定义好的属性和方法
class Student(id:String,name:String,age:Int,gender:String,clazz:String) extends Person(id,name,age){
  val _gender:String=gender
  val _clazz: String = clazz

  override def printName(): Unit = {
    println(s"这是Student类中的对象，名字为$name")
  }

  override def walk(): Unit ={
    println("Student也属于Person,也会行走")
  }

  def printGender(): Unit ={
    println(this._gender)
  }

  override def toString: String ={
    return s"Student(${_id},${_name},${_age},${_gender},${_clazz})"
  }
}

object Demo04ScalaClassExtend{
  //多态 父类引用指向子类对象
  def PersonWalkTwice(person:Person): Unit ={
    person.walk()
    person.walk()
  }

  def TeacherWalkTwice(teacher: Teacher): Unit ={
    teacher.walk()
    teacher.walk()
  }

  def StudentWalkTwice(student: Student): Unit ={
    student.walk()
    student.walk()
  }

  def main(args: Array[String]): Unit = {
    val p1: Person = new Person("001", "p1", 20)
    println(p1)
    println(p1._id)
    p1.walk()
    p1.printName()

    val t1: Teacher = new Teacher("002", "t1", 21,"文科一班")
    println(t1._clazz)

    val s1: Student = new Student("003", "s1", 22, "男", "文科二班")
    println(s1._gender)
    s1.printGender()

    PersonWalkTwice(p1)
    TeacherWalkTwice(t1)
    StudentWalkTwice(s1)

    PersonWalkTwice(t1)
    PersonWalkTwice(s1)
  }
}

 Person(001,p1,20)
001
人类会行走
这是Person类中的对象，名字为p1
文科一班
男
男
人类会行走
人类会行走
Teacher也属于Person,也会行走
Teacher也属于Person,也会行走
Student也属于Person,也会行走
Student也属于Person,也会行走
Teacher也属于Person,也会行走
Teacher也属于Person,也会行走
Student也属于Person,也会行走
Student也属于Person,也会行走

object Demo05CaseClass {
  def main(args: Array[String]): Unit = {
    val zs: CaseStudent = new CaseStudent("001", "zs", 20, "男", "文科一班")
    println(zs.id)
    println(zs.name)
    println(zs.gender)
    zs.age=21
    println(zs.age)

    println(zs)
  }
}

/**
 * 样例类
 * 实现序列化接口 可以在网络中传输
 * 所有的属性默认都是不可以修改的 如果需要修改 那么在定义的时候要使用var修饰 默认是由val修饰
 * 会重写默认的toString方法 如果直接打印 会输出对应的所有的属性值
 * 会自动给每个属性加上get、set(由var修饰的属性才会有)方法
 */
case class CaseStudent(id:String,name:String,var age:Int,gender:String,clazz:String)

 001
zs
男
21
CaseStudent(001,zs,21,男,文科一班)

import java.io.*;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Demo06WordCountJava {
    public static void main(String[] args) throws IOException {
        HashMap<String, Integer> wordMap = new HashMap<>();
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream("D:\\projects\\bigdata16\\Scala\\data\\words.txt")));
        String line="";
        while ((line= bufferedReader.readLine())!=null){
            String[] words = line.split(",");
            for (String word :
                    words) {
                if(wordMap.containsKey(word)) {
                    Integer value = wordMap.get(word);
                    wordMap.put(word,value+1);
                }else {
                    wordMap.put(word,1);
                }
            }
        }
        bufferedReader.close();
        //打印结果
        Set<Map.Entry<String, Integer>> entrySet = wordMap.entrySet();
        for (Map.Entry<String, Integer> entry : entrySet) {
            System.out.println(entry.getKey()+" : "+entry.getValue());
        }
    }
}

 java : 20
spark : 10
hadoop : 10

小胖超凶哦！
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
类和对象（封装、继承、多态）
沐雨
11-06 1955
文章目录一、内容一1、类和对象的基本概念（1）类（2）对象（3）类和对象的区别2、Java的数据类型3、对象大小二、内容二1、面向对象的三大基础特征（1）封装（2）继承（3）多态2、练习 一、内容一 1、类和对象的基本概念 （1）类 类：是抽象的概念集合，表示的是一个共性的产物，类之中定义的是属性和行为（方法）； 类的定义： class 类名{ 属性（变量）； 行为（方法）； } 例如：定义一个Person类 class Person { // 类名称首字母大写
第三章 封装
HKD_WCY的博客
04-18 3265
1、 下列关于构造方法的描述，错误的是（） 2分 A、一个类中只能定义一个空参数的构造方法 B、一个类中可以定义多个构造方法 C、构造方法的方法名前面没有返回值类型的声明 D、在构造方法中不能使用return语句返回一个值，但是可以单独使用return作为方法的结束 答案: A 【答案说明】 暂无 2、 以下关于成员属性与成员方法的描述中，错误的是（ ） 2分 A、成员属性我们也叫成员变量，它...
类和对象，继承与多态
km_1790的博客
10-19 161
1.：学习如何声明类和创建对象 类是一个模板，用户创建用以类型的对象， class<classname>{ <body of the class> } public class Person{ } 2.：学习构造方法的使用 Person person =new Person(); Person()就叫构造方法，构造方法其实就是生产对象的方法，方式； new Person()就是通过Person()这个构造方法所指定的方式来生产一个人类对象。 3.：了解方法重载 4.：...
Java学习笔记—类与对象、继承与多态
m0_55835914的博客
12-10 459
2021.12.10——Java学习笔记
Python学习笔记（六）：面向对象编程（创建类、对象、类属性、类的继承与多态）
wangc1994的博客
05-08 432
类和对象 类是对象的蓝图和模板，而对象是类的实例，类是抽象的概念，而对象是具体的东西，类可以产生多个对象，每个对象都有属性和行为，每个对象都是独一无二的。 定义类 在python中使用class关键字定义类，在类中使用函数定义方法 class First(object): ...
Python类继承和多态原理解析
09-18
主要介绍了python类继承和多态原理解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Java必须学会的类的继承与多态
08-24
主要介绍了Java类的继承与多态的相关资料，帮助大家更好的理解和学习Java，感兴趣的朋友可以了解下
C++物品销售系统、多态、类、继承
11-25
基于C++抽象封装集成多态开发的物品销售系统V1.0,体现了类的封装继承多态，数据处理采用文本方式
类的继承-动物.zip
10-12
在某游戏系统中，有猫、狗、猪三种动物。 （1） 三者都有吃的行为，建立一个动物类作为他们的父类，但是三种动物吃的行为都不相同，猫吃老鼠、狗吃骨头、猪吃饲料 ...考察知识点：继承、多态、instanceof
类的封装、继承和多态
03-23
第3章 类的封装、继承和多态 第4章 接口、内部类和Java API基础 第5章 异常处理 第6章 图形用户界面 第7章 多线程 第8章 Applet应用程序 第9章 输入/输出流和文件操作 第10章 网络通信 第11章 数据库应用 第12章 ...
java套打样例
03-18
NULL 博文链接：https://lin-yike.iteye.com/blog/587469
【JAVA学习】六、设计模式
xitianxiaofeixue的博客
09-11 176
六、设计模式 1. 单例模式 核心作用：保证一个类只有一个对象，提供一个方法访问这个对象。例如：回收站和任务管理器Spring的Bean就是。 优点：减少系统性能的开销。 实现方式：饿汉式，懒汉式 其他：双重检测锁，静态内部类，枚举单例 饿汉式 私有构造器，提供一个私有属性（创建一个对象），提供一个取对象方法。 public class Demo1 { //饿汉式，类初始化时立刻加载,线程安全调用效率高 private static Demo1 demo1 = new Demo1();
iOS组件化 - Github库上传到CocoaPods
卖报的小行家
09-05 482
一、上传自己的库到cocoapods 1、创建公共库文件 cd到桌面，执行 pod lib create PublicDemo 其中 PublicDemo 是要创建的库名。 会让输入一些问题，依次回答即可 创建完成以后会用xcode自动打开一个文件，就是我们需要的 PublicDemo 。 2、添加要上传的代码 打开桌面上的 PublicDemo 文件夹，将我们需要添加的代码...
java 类_Java类的定义及其实例化
weixin_32379547的博客
02-12 173
如果你不了解类和对象的概念，请猛击这里：Java类和对象的概念类必须先定义才能使用。类是创建对象的模板，创建对象也叫类的实例化。下面通过一个简单的例子来理解Java中类的定义：public class Dog{String name;int age;void bark(){ // 汪汪叫System.out.println("汪汪，不要过来");}void hungry(){ // 饥饿Sys...
8.类的继承
Cynan_Gattackon
03-29 8139
目录1.继承的定义2.继承的作用3. 继承的语法4. 类继承成员属性的访问权限5. 利用参数列表，初始化父类的私有成员6. 继承中的构造函数与析构函数7. 总结共继承的权限问题8.类中的隐藏问题9. 类中的多继承10.类中多级继承11. 菱形继承（引入：虚继承） 1.继承的定义 从父类中获取一些功能接口或 数据成员，如果该成员是共有或保护成员则子类可以直接访问，提高代码的复用性。 2.继承的作用 提高代码的复用性 有利于软件版本的升级 3. 继承的语法 class 类名: 继承方式 基类名（
java如何实例类_Java通用类,如何制作实例
weixin_39570838的博客
02-21 101
我具有以下类结构：public abstract class Genericpublic class SuperGenericextends Generic现在,我想制作一个涵盖所有可能类的SuperGeneric实例.我这样尝试过：Generic extends SuperClass & SomeInterface> myGeneric= new SuperGeneric exte...
java类实例
Lionel的博客
05-25 3418
一个简单的例子 在该例子中，我们创建两个类：Employee 和 EmployeeTest。 首先打开文本编辑器，把下面的代码粘贴进去。注意将文件保存为 Employee.java。 Employee类有四个成员变量：name、age、designation和salary。该类显式声明了一个构造方法，该方法只有一个参数. Employee.java 文件代码： import java.io.*; ...
java类的实例_Java 类实例
weixin_42479284的博客
02-17 875
Java面向对象设计 - Java类实例以下是创建类的实例的一般语法:new ;new运算符后面是对构造函数的调用。new运算符通过分配堆上的内存来创建类的实例。以下语句创建Dog类的实例:new Dog();Dog()是对Dog类的构造函数的调用。当我们不向类添加构造函数时，Java编译器为我们添加一个。Java编译器添加的构造函数称为默认构造函数。默认构造函数不接受参数。类的构造函数的名称与...
声明一个抽象类Person，此类中定义无参无返回值得抽象方法print()； 声明Teacher类、Student类，均继承自Person类，并复写了print()方法； 运用多态方式实例化子类对象并调用print()方法打印输出信息； 测试类： 定义父类成员p，分别指向不同的子类对象，调用print方法，观察结果。 【输入形式】无 【输出形式】 I am a Student,I love studying. I am a Teacher,I love teaching. 【样例输入】无
最新发布
06-08
以下是代码实现： ```java abstract class Person { public abstract void print(); } class Teacher extends Person { public void print() { System.out.println("I am a Teacher,I love teaching.");...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值