初识Java之基础语法篇（下）
前文中我们介绍了很多关于Java的一些语法知识，基础点，我们本期文章就把之前没有讲到的再说一次，然后以我自己理解的文字型的方式总结归纳一下。
Java 程序可以认为是一系列对象的集合，而这些对象通过调用彼此的方法来协同工作
所有的 Java 程序由 public static void main(String[] args) 方法开始执行
类变量的渗入
成员变量和类变量都是在方法之外，简单来说就是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" ); }
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
访问实例变量和方法
/* 实例化对象 */
Object referenceVariable = new Constructor();
/* 访问类中的变量 */
referenceVariable.variableName;
/* 访问类中的方法 */
referenceVariable.methodName();
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
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 ); }
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
一个源文件中只能有一个 public 类
一个源文件可以有多个非 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); }
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
这里写好了方法，那么只需要后面我们自己再去写一个程序进行实例化操作就可以了。对于里面的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(); }
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
我们来看看效果
这里我们就可以充分的理解了Java对于类的叠加是如此的强大了
引用类型
在Java中，引用类型的变量非常类似于C/C++的指针。引用类型指向一个对象，指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型，比如 Employee、Puppy 等。变量一旦声明后，类型就不能被改变了。
例如：
Site site = new Site(“Runoob”)
常量在程序运行时是不能被修改的。
在 Java 中使用 final 关键字来修饰常量，声明方式和变量类似
final double PI = 3.1415927;
- 1
数据类型转换必须满足如下规则：
-
不能对boolean类型进行类型转换。
-
不能把对象类型转换成不相关类的对象。
-
在把容量大的类型转换为容量小的类型时必须使用强制类型转换。
-
转换过程中可能导致溢出或损失精度。
如果要进行强制的转换就需要在前面加一个括号
public class QiangZhiZhuanHuan{ public static void main(String[] args){ int i1 = 123; byte b = (byte)i1;//强制类型转换为byte System.out.println("int强制类型转换为byte后的值等于"+b); }
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
实例变量
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(); }
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
这个程序首先声明了实例变量的属性，共同的，最后又声明了薪水的属性为私有的，但是在这个程序里面还是可以运行的。之后对每个变量进行赋值，这里之所以用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); }
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
Java修饰符
再次提醒！！！！！！！！！！
default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
public : 对所有类可见。使用对象：类、接口、变量、方法
protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。
- 1
- 2
- 3
- 4
- 5
- 6
- 7
private
私有访问修饰符是最严格的访问级别，所以被声明为 private 的方法、变量和构造方法只能被所属类访问，并且类和接口不能声明为 private。
声明为私有访问类型的变量只能通过类中公共的 getter 方法被外部类访问。
public class Logger { private String format; public String getFormat() { return this.format; } public void setFormat(String format) { this.format = format; }
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
实例中，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"); }
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
运算符
不管是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); }
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
特别需要注意的是三元运算符
在之前的文章里面我也详细的介绍了
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); }
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
true
Java运算符优先级
Java的基础语法不比得Python的简单易懂，我们这里总结了两篇，才结束，总的来说第一篇是泛泛而谈，第二篇是基础加实战操作，上图解释，希望大家在今后的学习中不断运用。
后期我们可能要学习方法和流程控制与语言结构。
每文一语
生活就是让我们感受快乐的，至于更高境界的快乐那就是意义所带来的愉悦了。
文章来源: blog.csdn.net，作者：王小王-123，版权归原作者所有，如需转载，请联系作者。
原文链接：blog.csdn.net/weixin_47723732/article/details/108306085
- 点赞
- 收藏
- 关注作者
评论（0）