初识Java之基础语法篇(下)

时间:2020-8-31 作者:admin


前文中我们介绍了很多关于Java的一些语法知识,基础点,我们本期文章就把之前没有讲到的再说一次,然后以我自己理解的文字型的方式总结归纳一下。

Java 程序可以认为是一系列对象的集合,而这些对象通过调用彼此的方法来协同工作

所有的 Java 程序由 public static void main(String[] args) 方法开始执行

初识Java之基础语法篇(下)
类变量的渗入

成员变量和类变量都是在方法之外,简单来说就是main()的外面,此外成员变量需要在方法内进行实例化操作,就和我们Python实例化的概念差不多。

创建对象

声明一个对象,包括对象名称和对象类型。
使用关键字 new 来创建一个对象。
使用 new 创建对象时,会调用构造方法初始化对象。


public class Puppy{
   public Puppy(String name){
      //这个构造器仅有一个参数:name
      System.out.println("小狗的名字是 : " + name ); 
   }
   public static void main(String[] args){
      // 下面的语句将创建一个Puppy对象
      Puppy myPuppy = new Puppy( "tommy" );
   }
}

访问实例变量和方法


/* 实例化对象 */
Object referenceVariable = new Constructor();
/* 访问类中的变量 */
referenceVariable.variableName;
/* 访问类中的方法 */
referenceVariable.methodName();

package com.company;

public class Puppy {
    int puppyAge;
    public Puppy(String name){
        // 这个构造器仅有一个参数:name
        System.out.println("小狗的名字是 : " + name );
    }

    public void setAge( int age ){
        puppyAge = age;
    }

    public int getAge( ){
        System.out.println("小狗的年龄为 : " + puppyAge );
        return puppyAge;
    }

    public static void main(String[] args){
        /* 创建对象 */
        Puppy myPuppy = new Puppy( "tommy" );
        /* 通过方法来设定age */
        myPuppy.setAge( 2 );
        /* 调用另一个方法获取age */
        myPuppy.getAge( );
        /*你也可以像下面这样访问成员变量 */
        System.out.println("变量值 : " + myPuppy.puppyAge );
    }
}

初识Java之基础语法篇(下)

一个源文件中只能有一个 public 类
初识Java之基础语法篇(下)

一个源文件可以有多个非 public 类

类的高级用法
第一步先自己写好一个方法,后面我们自己好调用

package com.company;


import java.io.*;

public class Employee{
    String name;
    int age;
    String designation;
    double salary;
    // Employee 类的构造器
    public Employee(String name){
        this.name = name;
    }
    // 设置age的值
    public void empAge(int empAge){
        age =  empAge;
    }
    /* 设置designation的值*/
    public void empDesignation(String empDesig){
        designation = empDesig;
    }
    /* 设置salary的值*/
    public void empSalary(double empSalary){
        salary = empSalary;
    }
    /* 打印信息 */
    public void printEmployee(){
        System.out.println("名字:"+ name );
        System.out.println("年龄:" + age );
        System.out.println("职位:" + designation );
        System.out.println("薪水:" + salary);
    }
}

这里写好了方法,那么只需要后面我们自己再去写一个程序进行实例化操作就可以了。对于里面的this我们要记住这个是指向当前对象的引用!!!

package com.company;
import java.io.*;
public class EmployeeTest{

    public static void main(String[] args){
        /* 使用构造器创建两个对象 */
        Employee empOne = new Employee("王小王-1");
        Employee empTwo = new Employee("王小王-2");

        // 调用这两个对象的成员方法
        empOne.empAge(26);
        empOne.empDesignation("爬虫工程师");
        empOne.empSalary(20000);
        empOne.printEmployee();

        empTwo.empAge(21);
        empTwo.empDesignation("数据分析师");
        empTwo.empSalary(25000);
        empTwo.printEmployee();
    }
}

我们来看看效果

初识Java之基础语法篇(下)这里我们就可以充分的理解了Java对于类的叠加是如此的强大了

引用类型

在Java中,引用类型的变量非常类似于C/C++的指针。引用类型指向一个对象,指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型,比如 Employee、Puppy 等。变量一旦声明后,类型就不能被改变了。

例如:
Site site = new Site(“Runoob”)

常量在程序运行时是不能被修改的。

在 Java 中使用 final 关键字来修饰常量,声明方式和变量类似

final double PI = 3.1415927;

数据类型转换必须满足如下规则:

  1. 不能对boolean类型进行类型转换。

  2. 不能把对象类型转换成不相关类的对象。

  3. 在把容量大的类型转换为容量小的类型时必须使用强制类型转换。

  4. 转换过程中可能导致溢出或损失精度。

如果要进行强制的转换就需要在前面加一个括号


public class QiangZhiZhuanHuan{
    public static void main(String[] args){
        int i1 = 123;
        byte b = (byte)i1;//强制类型转换为byte
        System.out.println("int强制类型转换为byte后的值等于"+b);
    }
}

实例变量

package 基础语法;

public class 实例变量 {
    // 这个实例变量对子类可见
    public String name;
    // 私有变量,仅在该类可见
    private double salary;
    //在构造器中对name赋值
    public 实例变量 (String empName){
        name = empName;
    }
    //设定salary的值
    public void setSalary(double empSal){
        salary = empSal;
    }
    // 打印信息
    public void printEmp(){
        System.out.println("名字 : " + name );
        System.out.println("薪水 : " + salary);
    }

    public static void main(String[] args){
        实例变量 empOne = new 实例变量("王小王");
        empOne.setSalary(10000.0);
        empOne.printEmp();
    }
}

初识Java之基础语法篇(下)

这个程序首先声明了实例变量的属性,共同的,最后又声明了薪水的属性为私有的,但是在这个程序里面还是可以运行的。之后对每个变量进行赋值,这里之所以用public void 方法名(){数据类型 变量名}是因为这里并没有返回值,所以我们用void关键字。

类变量(静态变量)

类变量也称为静态变量,在类中以 static 关键字声明,但必须在方法之外。
静态变量在第一次被访问时创建,在程序结束时销毁。

package 基础语法;
import java.io.*;
public class 静态变量 {
    //salary是静态的私有变量
    private static double salary;
    // DEPARTMENT是一个常量
    public static final String DEPARTMENT = "数据分析师";
    public static void main(String[] args){
        salary = 10000;
        System.out.println(DEPARTMENT+"平均工资:"+salary);
    }
}

初识Java之基础语法篇(下)
Java修饰符

再次提醒!!!!!!!!!!

default (即默认,什么也不写): 在同一包内可见,不使用任何修饰符。使用对象:类、接口、变量、方法。

private : 在同一类内可见。使用对象:变量、方法。 注意:不能修饰类(外部类)

public : 对所有类可见。使用对象:类、接口、变量、方法

protected : 对同一包内的类和所有子类可见。使用对象:变量、方法。 注意:不能修饰类(外部类)。

private
私有访问修饰符是最严格的访问级别,所以被声明为 private 的方法、变量和构造方法只能被所属类访问,并且类和接口不能声明为 private。
声明为私有访问类型的变量只能通过类中公共的 getter 方法被外部类访问。


public class Logger {
   private String format;
   public String getFormat() {
      return this.format;
   }
   public void setFormat(String format) {
      this.format = format;
   }
}

实例中,Logger 类中的 format 变量为私有变量,所以其他类不能直接得到和设置该变量的值。为了使其他类能够操作该变量,定义了两个 public 方法:getFormat() (返回 format的值)和 setFormat(String)(设置 format 的值)
public
被声明为 public 的类、方法、构造方法和接口能够被任何其他类访问。
如果几个相互访问的 public 类分布在不同的包中,则需要导入相应 public 类所在的包。由于类的继承性,类所有的公有方法和变量都能被其子类继承。

projected
子类与基类在同一包中:被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问;
子类与基类不在同一包中:那么在子类中,子类实例可以访问其从基类继承而来的 protected 方法,而不能访问基类实例的protected方法。

这个最难理解,详情点击了解

修饰符

这里只介绍一下static

package 基础语法;

public class 修饰符static {
    private static int numInstances = 0;
    protected static int getCount() {
        return numInstances;
    }

    private static void addInstance() {
        numInstances++;
    }

    修饰符static() {
        修饰符static.addInstance();
    }

    public static void main(String[] arguments) {
        System.out.println("Starting with " +
                修饰符static.getCount() + " instances");
        for (int i = 0; i < 500; ++i){
            new 修饰符static();
        }
        System.out.println("Created " +
                修饰符static.getCount() + " instances");
    }

}

初识Java之基础语法篇(下)
运算符
不管是Java还是Python,或者是c运算符都是大同小异,我们要了解的可能和Python的有所不同。

这里要强调判断的是递增运算符合递减运算符,前++是先运算后赋值,并且改变原来的那个变量值。(原来的变量也改变了)
后++是先赋值后运算,那就是先把这个值打印出来,最后进行运算(改变最后本身值,原来的那个值也改变了)

package 基础语法;

public class 运算符 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 25;
        int d = 25;
        System.out.println("a + b = " + (a + b) );
        System.out.println("a - b = " + (a - b) );
        System.out.println("a * b = " + (a * b) );
        System.out.println("b / a = " + (b / a) );
        System.out.println("b % a = " + (b % a) );
        System.out.println("c % a = " + (c % a) );
        System.out.println("a++   = " +  (a++) );
        System.out.println("a--   = " +  (a--) );
        // 查看  d++ 与 ++d 的不同
        System.out.println("d++   = " +  (d++) );
        System.out.println("++d   = " +  (++d) );
        System.out.println(++d);
    }
}

初识Java之基础语法篇(下)
初识Java之基础语法篇(下)
初识Java之基础语法篇(下)
特别需要注意的是三元运算符

在之前的文章里面我也详细的介绍了

instanceof 运算符

String name = “James”;
boolean result = name instanceof String; // 由于 name 是 String 类型,所以返回真


class Vehicle {}
 
public class Car extends Vehicle {
   public static void main(String[] args){
      Vehicle a = new Car();
      boolean result =  a instanceof Car;
      System.out.println( result);
   }
}

true

Java运算符优先级

初识Java之基础语法篇(下)
Java的基础语法不比得Python的简单易懂,我们这里总结了两篇,才结束,总的来说第一篇是泛泛而谈,第二篇是基础加实战操作,上图解释,希望大家在今后的学习中不断运用。

后期我们可能要学习方法和流程控制与语言结构。

每文一语

生活就是让我们感受快乐的,至于更高境界的快乐那就是意义所带来的愉悦了。

声明:本文内容由互联网用户自发贡献自行上传,本网站不拥有所有权,未作人工编辑处理,也不承担相关法律责任。如果您发现有涉嫌版权的内容,欢迎进行举报,并提供相关证据,工作人员会在5个工作日内联系你,一经查实,本站将立刻删除涉嫌侵权内容。