这篇博客主要介绍了Java的基础知识，包括Java的源程序与编译型运行的区别、枚举、对象和类的概念，以及基本数据类型和修饰符的使用。详细讲解了构造方法、对象创建过程，同时探讨了访问控制修饰符和非访问控制修饰符的应用。
目录
$ javac HelloWorld.java // java 源文件（.java）编译成字节码文件（.class）
$ java HelloWorld //运行程序
Hello WorldJava丢弃特性：操作符重载、多继承、自动的强制类型转换。
面向对象：提供类、接口和继承等面向对象的特性，
Java 开发环境配置：下载JDK——配置环境变量——测试JDK是否安装成功；
1. Java基础语法
类名：单词首字母大写—— MyFirstJavaClass ；
方法名：小写，多单词首字母大写；
源文件名：必须和类名相同。
Java 源程序与编译型运行区别
Java 枚举
注意：枚举可以单独声明或者声明在类里面。方法、变量、构造函数也可以在枚举中定义。
class FreshJuice {
enum FreshJuiceSize{ SMALL, MEDIUM , LARGE } //限制果汁为小杯、中杯、大杯
FreshJuiceSize size;
}
public class FreshJuiceTest {
public static void main(String[] args){
FreshJuice juice = new FreshJuice();
juice.size = FreshJuice.FreshJuiceSize.MEDIUM;
System.out.println(juice.size); //MEDIUM
}
}2.Java 对象和类
- 多态：
- 继承：
- 封装：
- 抽象：
- 类：是一个模板，它描述一类对象的行为和状态。
- 对象：是类的一个实例，有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。
- 实例：
- 方法：就是行为（能做什么），一个类可以有很多方法。逻辑运算、数据修改以及所有动作都是在方法中完成的。
- 重载：
类型变量 ：
- 局部变量（方法中）：在方法、构造方法或者语句块中定义的变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
- 成员变量（类中，方法外）：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
- 类变量（类中，方法外，static 类型）：类变量也声明在类中，方法体之外，但必须声明为 static 类型。
男孩（boy）、女孩（girl）为两个类（class），而具体的每一个人为该类的对象（object）
汽车为类（class），而具体的每辆车为该汽车类的对象（object），对象包含了汽车的颜色、品牌、名称等。
public class Dog {
String breed; //属性
int size;
String colour;
int age;
void eat() { //方法
}
void run() {
}
void sleep(){
}
void name(){
}
}2.1 构造方法（与类同名，可多个）——参数不同
在创建一个对象时，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法。
public class Puppy{
public Puppy(){
}
public Puppy(String name){
// 这个构造器仅有一个参数：name
}
}2.2 创建对象（声明——实例化——初始化）
- 声明：声明一个对象，包括对象名称和对象类型。
- 实例化：使用关键字 new 来创建一个对象。
- 初始化：使用 new 创建对象时，会调用构造方法初始化对象。
Puppy.java （一个源文件中只能有一个 public 类）
public class Puppy{
public Puppy(String name){ //构造方法仅有一个参数：name
System.out.println("小狗的名字是 : " + name );
}
public static void main(String[] args){
Puppy myPuppy = new Puppy( "tommy" ); //创建一个Puppy对象（类型），myPuppy（对象名称）
}
}
//小狗的名字是 : tommypublic 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（对象名称）
Puppy myPuppy = new Puppy("tommy"); /* 实例化对象 */
myPuppy.setAge(2); /* 1.通过方法来设定age */
myPuppy.getAge(); /* 调用另一个方法获取age */
/* 2.访问类中的成员变量puppyAge */
System.out.println("变量值 : " + myPuppy.puppyAge);
}
}
/*
小狗的名字是 : tommy
小狗的年龄为 : 2
变量值 : 2
*/1.Employee.java：程序都是从main方法开始执行。为了能运行这个程序，必须包含main方法并且创建一个实例对象。
import java.io.*;
public class Employee{
String name;
int age;
String designation;
double salary;
public Employee(String name){ // Employee 类的构造方法
this.name = name;
}
public void empAge(int empAge){
age = empAge;
}
public void empDesignation(String empDesig){
designation = empDesig;
}
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);
}
}
2.EmployeeTest.java：该类实例化2个 Employee 类的实例，并调用方法设置变量的值。
import java.io.*;
public class EmployeeTest{
public static void main(String[] args){
/* 使用构造器创建两个对象 */
Employee empOne = new Employee("RUNOOB1");
Employee empTwo = new Employee("RUNOOB2");
// 调用这两个对象的成员方法
empOne.empAge(26);
empOne.empDesignation("高级程序员");
empOne.empSalary(1000);
empOne.printEmployee();
empTwo.empAge(21);
empTwo.empDesignation("菜鸟程序员");
empTwo.empSalary(500);
empTwo.printEmployee();
}
}
/*
名字:RUNOOB1
年龄:26
职位:高级程序员
薪水:1000.0
名字:RUNOOB2
年龄:21
职位:菜鸟程序员
薪水:500.0
*/3.Java 基本数据类型
| 类别 | 关键字 | 说明 |
|---|---|---|
| 访问控制 | private | 私有的 |
| protected | 受保护的 | |
| public | 公共的 | |
| default | 默认 | |
| 类、方法和变量修饰符 | abstract | 声明抽象 |
| class | 类 | |
| extends | 扩充,继承 | |
| final | 最终值,不可改变的 | |
| implements | 实现（接口） | |
| interface | 接口 | |
| native | 本地，原生方法 （非 Java 实现） | |
| new | 新,创建 | |
| static | 静态 | |
| strictfp | 严格,精准 | |
| synchronized | 线程,同步 | |
| transient | 短暂 | |
| volatile | 易失 | |
| 程序控制语句 | break | 跳出循环 |
| case | 定义一个值以供 switch 选择 | |
| continue | 继续 | |
| do | 运行 | |
| else | 否则 | |
| for | 循环 | |
| if | 如果 | |
| instanceof | 实例 | |
| return | 返回 | |
| switch | 根据值选择执行 | |
| while | 循环 | |
| 错误处理 | assert(断言表达式是否为真) | |
| catch | 捕捉异常 | |
| finally | 有没有异常都执行 | |
| throw | 抛出一个异常对象 | |
| throws | 声明一个异常可能被抛出 | |
| try | 捕获异常 | |
| 包相关 | import | 引入 |
| package | 包 | |
| 八种基本类型 { 1.四个整数型； long a = 100000L；float f1 = 234.5f 2.两个浮点型； 3.一种字符类型； 最小值是 \u0000(十进制为 0) 最大值是 \uffff(即为 65535) 4.一种布尔型； } | boolean | 布尔型1位 默认值false |
| byte | 字节型8位 -2^7~2^7-1 | |
| char | 字符型16 位 | |
| double | 双精度浮点64位 | |
| float | 单精度浮点32位 | |
| int | 整型32位 -2^31~2^31 - 1 | |
| long | 长整型64位 （-2^63~2^63 -1） | |
| short | 短整型16位 -2^15~2^15-1 | |
| 变量引用 | super | 父类,超类 |
| this | 本类 | |
| void | 无返回值 | |
| 保留关键字 | goto | 是关键字，但不能使用 |
| const | 是关键字，但不能使用 |
public class PrimitiveTypeTest {
public static void main(String[] args) {
// byte
System.out.println("基本类型：byte 二进制位数：" + Byte.SIZE);
System.out.println("包装类：java.lang.Byte");
System.out.println("最小值：Byte.MIN_VALUE=" + Byte.MIN_VALUE);
System.out.println("最大值：Byte.MAX_VALUE=" + Byte.MAX_VALUE);
System.out.println();
// short
System.out.println("基本类型：short 二进制位数：" + Short.SIZE);
System.out.println("包装类：java.lang.Short");
System.out.println("最小值：Short.MIN_VALUE=" + Short.MIN_VALUE);
System.out.println("最大值：Short.MAX_VALUE=" + Short.MAX_VALUE);
System.out.println();
// int
System.out.println("基本类型：int 二进制位数：" + Integer.SIZE);
System.out.println("包装类：java.lang.Integer");
System.out.println("最小值：Integer.MIN_VALUE=" + Integer.MIN_VALUE);
System.out.println("最大值：Integer.MAX_VALUE=" + Integer.MAX_VALUE);
System.out.println();
// long
System.out.println("基本类型：long 二进制位数：" + Long.SIZE);
System.out.println("包装类：java.lang.Long");
System.out.println("最小值：Long.MIN_VALUE=" + Long.MIN_VALUE);
System.out.println("最大值：Long.MAX_VALUE=" + Long.MAX_VALUE);
System.out.println();
// float
System.out.println("基本类型：float 二进制位数：" + Float.SIZE);
System.out.println("包装类：java.lang.Float");
System.out.println("最小值：Float.MIN_VALUE=" + Float.MIN_VALUE);
System.out.println("最大值：Float.MAX_VALUE=" + Float.MAX_VALUE);
System.out.println();
// double
System.out.println("基本类型：double 二进制位数：" + Double.SIZE);
System.out.println("包装类：java.lang.Double");
System.out.println("最小值：Double.MIN_VALUE=" + Double.MIN_VALUE);
System.out.println("最大值：Double.MAX_VALUE=" + Double.MAX_VALUE);
System.out.println();
// char
System.out.println("基本类型：char 二进制位数：" + Character.SIZE);
System.out.println("包装类：java.lang.Character");
// 以数值形式而不是字符形式将Character.MIN_VALUE输出到控制台
System.out.println("最小值：Character.MIN_VALUE="
+ (int) Character.MIN_VALUE);
// 以数值形式而不是字符形式将Character.MAX_VALUE输出到控制台
System.out.println("最大值：Character.MAX_VALUE="
+ (int) Character.MAX_VALUE);
}
}
/*
基本类型：byte 二进制位数：8
包装类：java.lang.Byte
最小值：Byte.MIN_VALUE=-128
最大值：Byte.MAX_VALUE=127
基本类型：short 二进制位数：16
包装类：java.lang.Short
最小值：Short.MIN_VALUE=-32768
最大值：Short.MAX_VALUE=32767
基本类型：int 二进制位数：32
包装类：java.lang.Integer
最小值：Integer.MIN_VALUE=-2147483648
最大值：Integer.MAX_VALUE=2147483647
基本类型：long 二进制位数：64
包装类：java.lang.Long
最小值：Long.MIN_VALUE=-9223372036854775808
最大值：Long.MAX_VALUE=9223372036854775807
基本类型：float 二进制位数：32
包装类：java.lang.Float
最小值：Float.MIN_VALUE=1.4E-45
最大值：Float.MAX_VALUE=3.4028235E38
基本类型：double 二进制位数：64
包装类：java.lang.Double
最小值：Double.MIN_VALUE=4.9E-324
最大值：Double.MAX_VALUE=1.7976931348623157E308
基本类型：char 二进制位数：16
包装类：java.lang.Character
最小值：Character.MIN_VALUE=0
最大值：Character.MAX_VALUE=65535
*/引用类型的变量非常类似于C/C++的指针。引用类型指向一个对象，指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型，比如 Employee、Puppy 等。变量一旦声明后，类型就不能被改变了。对象、数组都是引用数据类型。
Java 常量：final double PI = 3.1415927;
自动类型转换：
低 ------------------------------------> 高
byte,short,char—> int —> long—> float —> double 变量类型：
- 类变量（静态变量）：独立于方法之外的变量，用 static 修饰。static int allClicks=0; 声明为 public/private，final 和 static 类型的变量。静态变量初始化后不可改变。
- 实例变量（成员变量）：独立于方法之外的变量，不过没有 static 修饰。
- 局部变量：类的方法中的变量。在栈上分配的。必须初始化。
import java.io.*;
public class Employee {
public String name; // 这个实例变量对子类可见
private double salary; // 私有变量，仅在该类可见
public Employee (String empName){ //在构造器中对name赋值
name = empName;
}
public void setSalary(double empSal){ //设定salary的值
salary = empSal;
}
public void printEmp(){
System.out.println("名字 : " + name );
System.out.println("薪水 : " + salary);
}
public static void main(String[] args){
Employee empOne = new Employee("RUNOOB");
empOne.setSalary(1000.0);
empOne.printEmp();
}
}
/*
名字 : RUNOOB
薪水 : 1000.0
*/public class Employee {
private static double salary; //salary是静态的私有变量
public static final String DEPARTMENT = "开发人员"; // DEPARTMENT是一个常量
public static void main(String[] args){
salary = 10000; //可以直接赋值，不用通过对象
System.out.println(DEPARTMENT+"平均工资:"+salary);
}
}
/*
开发人员平均工资:10000.0
*/4.Java 修饰符
4.1 访问控制修饰符
-
default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
-
private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类），类和接口不能声明为 private。
-
public : 对所有类可见。使用对象：类、接口、变量、方法
-
protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。接口及接口的成员变量和成员方法不能声明为 protected。
public class Logger {
private String format;
public String getFormat() {
return this.format;
}
public void setFormat(String format) {
this.format = format;
}
}private：Logger 类中的 format 变量为私有变量，所以其他类不能直接得到和设置该变量的值。为了使其他类能够操作该变量，定义了两个 public 方法：getFormat() （返回 format的值）和 setFormat(String)（设置 format 的值）
class AudioPlayer {
protected boolean openSpeaker(Speaker sp) {
// 实现细节
}
}
class StreamingAudioPlayer extends AudioPlayer {
protected boolean openSpeaker(Speaker sp) {
// 实现细节
}
}protected ：子类能访问 protected 修饰符声明的方法和变量，这样就能保护不相关的类使用这些方法和变量。父类使用了 protected 访问修饰符，子类重写了父类的 openSpeaker() 方法。如果把openSpeaker() 方法声明为 private，那么除了 AudioPlayer 外，其他类将不能访问该方法。
访问控制和继承：
-
父类中声明为 public 的方法在子类中也必须为 public。
-
父类中声明为 protected 的方法在子类中要么声明为 protected，要么声明为 public，不能声明为 private。
-
父类中声明为 private 的方法，不能够被子类继承。
4.2 非访问控制修饰符
-
static 修饰符：静态变量也被称为类变量。局部变量不能被声明为 static 变量；静态方法不能使用类的非静态变量。
-
final 修饰符（防止被修改）：变量一旦赋值后，不能被重新赋值。final 修饰符通常和 static 修饰符一起使用来创建类常量。final 类不能被继承。父类中的 final 方法可以被子类继承，但是不能被子类重写。
-
abstract 修饰符（扩充类）：抽象类不能用来实例化对象。如果一个类包含抽象方法，那么该类一定要声明为抽象类。（有抽象方法的一定是抽象类）
-
synchronized 修饰符（加锁）：同一时间只能被一个线程访问。
-
transient 修饰符（预处理类和变量的数据类型）：序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的变量。
-
volatile 修饰符：每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
public class InstanceCounter {
private static int numInstances = 0; //静态私有变量
protected static int getCount() { //静态保护方法
return numInstances;
}
private static void addInstance() { //静态私有方法
numInstances++;
}
InstanceCounter() {
InstanceCounter.addInstance();
}
public static void main(String[] arguments) {
System.out.println("Starting with " +
InstanceCounter.getCount() + " instances");
for (int i = 0; i < 500; ++i){
new InstanceCounter();
}
System.out.println("Created " +
InstanceCounter.getCount() + " instances");
}
}
/*
Starting with 0 instances
Created 500 instances
*/static：使用同类中的getCount()获取静态私有变量numInstances，使用同类中的InstanceCounter()方法获取静态私有方法addInstance()对numInstances进行赋值。
public class Test{
//类体
public final void changeName(){ //final
// 方法体
}
}public abstract class Caravan{ //抽象类
private double price;
private String model;
private String year;
public abstract void goFast(); //抽象方法
public abstract void changeColor();
}public synchronized void showDetails(){ //synchronized
.......
}public transient int limit = 55; // transient 不会持久化
public int b; // 持久化public class MyRunnable implements Runnable
{
private volatile boolean active; //volatile
public void run()
{
active = true;
while (active) // 第一行
{
// 代码
}
}
public void stop()
{
active = false; // 第二行
}
}通常情况下，在一个线程调用 run() 方法（在 Runnable 开启的线程），在另一个线程调用 stop() 方法。 如果 第一行 中缓冲区的 active 值被使用，那么在 第二行 的 active 值为 false 时循环不会停止。但是以上代码中我们使用了 volatile 修饰 active，所以该循环会停止。
扫一扫
16万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
