zoukankan      html  css  js  c++  java
  • 第31节:Java基础-类与对象

    标题图

    前言

    Java基础-类与对象,方法的重载,构造方法的重载,static关键字,main()方法,this关键字,包,访问权限,类的继承,继承性,方法的重写,super变量。

    方法的重载:成员方法的重载和构造方法的重载

    方法的重载

    在一个类中可以有多个方法具有相同的名字,但是这些方法的参数个数不同,或参数类型不同,即为方法的重载。

    class Demo{
     // one
     void dashu(String name){
      System.out.println(name);
     }
     // two
     void dashu(String name,String score){
      System.out.println(name+score);
     }
     // three
     void dashu(String name,String score,Int age){
      System.out.println(name+score+age);
     }
      public static void main(String[] args){
       Demo demo = new Demo();
       demo.dashu("dashucoding");
       demo.dashu("dashucoding","一百");
       demo.dashu("dashucoding","一百",10);
      }
    }

    构造方法的重载

    class Person{
     String name;
     int age;
     float height;
     float weight;
     // 构造方法
     public Person(){
      age = 13;
      name="dashu"
     }
     public Person(String name){
      this.name = name;
     }
     // 构造方法的重载
     public Person(String name, int age){
      this.name = name;
      this.age = age;
     }
     void print(){
      System.out.println(name+age);
     }
    }
    class Test{
     public static void main(String[] args){
      Demo demo1,demo2,demo3;
      demo1 = new Demo();
      demo2 = new Demo("dashu");
      demo3 = new Demo("dashu",12);
      demo1.print();
      demo2.print();
      demo3.print();
     }
    }

    static关键字

    static修饰的变量为静态变量
    static修饰的方法为静态方法

    静态变量属于类而不属于类的某个实例,可被直接类名调用,所以叫类变量
    静态方法属于类而不属于类的某个实例,可被直接类名调用,所以叫类方法

    非静态的成员变量和方法,必须通过实例化后通过对象名来调用
    所以叫实例变量和实例方法

    实例变量和实例方法通过实例调用,类变量和类方法同样也可以通过实例调用
    这点要注意


    main()方法

    main()方法为静态的,在java虚拟机中执行main()方法时不需要创建main()方法所在类的实例就可调用,因为有static修饰。

    例子

    class Demo{
     // 定义静态的成员变量
     static int x;
     int y;
     // 定义静态的成员方法,用来获取值
     public static int getX(){
      return x;
     }
     // 定义静态的成员方法,用来设置值
     public static void setX(int newX){
       x = newX;
      }
     public int getY(){
      return y;
     }
     public void setY(int newY){
      y = newY;
     }
    }

    静态方法可以调用同类的静态成员,不能调用非静态成员,反之能;静态成员可通过类名调用,也可通过实例对象,静态方法中不能使用thissuper

    this关键字

    this代表使用该方法的当前的对象,只用于实例方法或者构造方法中。

    void setAge(int age){
     this.age = age;
    } 
    Person(String name, int age){
     this.name = name;
     this.age = age; 
    }

    java中提供了不同的类和接口存放在不同的包中。
    常见的包

    java.applet
    java.awt
    java.net
    java.util
    java.lang
    java.io

    包的格式:

    package 包名[.子包名[…]];

    引入java包

    import  包层次结构的类名;

    访问权限

    修饰符:

    publicprivateprotected、友好

    private变量和方法

    访问权限最小,只能在同一个类中被访问,私有成员可以被对象实例调用,方法被对象实例调用,静态成员可以被类名直接调用。

    class Demo{
     private static String name;
     private int age;
     private void print(){
      System.out.println(name+age);
     }
     public static void main(String[] args){
     Demo.name = "dashu";
     Demo d = new Demo();
     d.age = 12;
     d.print();
     }
    }

    private,类中的私有变量不能被另一个类所引用,私有变量和方法只能在本类中使用。

    class Demo{
     private static String name;
     private int age;
     private void print(){
      System.out.println(name+age);
     }
     public static void main(String[] args){
     Demo.name = "dashu";
     Demo d = new Demo();
     d.age = 12;
     d.print();
     }
    }
    // 另一类
    class Da{
     public static void main(String[] args){
      // 非法使用
     Demo.name = "dashu";
     // 非法调用
     Demo d = new Demo();
     d.print();
     }
    }

    public 访问修饰符,它的访问权限在不同类,不同包的类中访问

    默认,友好权限只能被同类或同包中的不同类引用

    protected不能在不同包中的类所引用

    访问权限 public protected 友好 private
    同类 可以 可以 可以 可以
    同包不同类 可以 可以 可以
    不同包子类 可以 可以
    通用 可以

    类的继承

    java中可以单继承,不支持多继承,一个子类只能有一个父类,不能有多个,但一个父类可以有多个派生的子类。

    public class Person{
         String name;
         int age;
         public void setAge(int age) {
        this.age=age;
         }
         public void out()   {
            System.out.println("姓名:"+name+" 年龄:"+age+"岁");      
         }
    }
    
    // 子类继承父类
    public class Student extends Person{
     ...
    }

    继承性

    子类继承父类,可以继承父类中非私有成员(子类和父类在同一包中),如果不在同一包中,子类只能继承父类中受保护的和公有的成员。

    方法的重写

    方法的重写,子类覆盖父类的方法,定义了与父类相同名,相同类型,并且相同参数的方法。

    super变量

    super,提供了对父类的访问,可以访问父类被子类的隐藏的变量和覆盖的方法。

    结语

    • 本文主要讲解 Java基础-类与对象
    • 下面我将继续对Java、 Android中的其他知识 深入讲解 ,有兴趣可以继续关注
    • 小礼物走一走 or 点赞

    送❤

  • 相关阅读:
    JID 2.0 RC4 发布,高性能的 Java 序列化库
    FBReaderJ 1.6.3 发布,Android 电子书阅读器
    Arquillian 1.0.3.Final 发布,单元测试框架
    JavaScript 的宏扩展 Sweet.js
    Hypertable 0.9.6.5 发布,分布式数据库
    JRuby 1.7.0 发布,默认使用 Ruby 1.9 模式
    httppp 1.4.0 发布,HTTP响应时间监控
    Redis 2.6.0 正式版发布,高性能K/V服务器
    OfficeFloor 2.5.0 发布,IoC 框架
    XWiki 4.3 首个里程碑发布
  • 原文地址:https://www.cnblogs.com/dashucoding/p/11932510.html
Copyright © 2011-2022 走看看