Java基本知识

最新推荐文章于 2024-10-01 18:51:18 发布

稀奇古怪de

最新推荐文章于 2024-10-01 18:51:18 发布

阅读量478

点赞数

文章标签： java

原文链接：https://www.runoob.com/java/java-basic-syntax.html

版权

java 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

参考文档菜鸟教程

类与对象

一个类可以包含以下类型变量：

局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
类变量：类变量也声明在类中，方法体之外，但必须声明为static类型。

构造方法

每个类都有构造方法。如果没有显式地为类定义构造方法，Java编译器将会为该类提供一个默认构造方法。

构造方法的名称必须与类同名，一个类可以有多个构造方法。

创建对象需要以下三步：

声明：声明一个对象，包括对象名称和对象类型。
实例化：使用关键字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" );
   }
}

源文件声明规则

当在一个源文件中定义多个类，并且还有import语句和package语句时，要特别注意这些规则。

一个源文件中只能有一个public类
一个源文件可以有多个非public类
源文件的名称应该和public类的类名保持一致。例如：源文件中public类的类名是Employee，那么源文件应该命名为Employee.java。
如果一个类定义在某个包中，那么package语句应该在源文件的首行。
如果源文件包含import语句，那么应该放在package语句和类定义之间。如果没有package语句，那么import语句应该在源文件中最前面。
import语句和package语句对源文件中定义的所有类都有效。在同一源文件中，不能给不同的类不同的包声明。

Java包

包主要用来对类和接口进行分类

基本数据类型

内置数据类型

Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。

byte：

byte 数据类型是8位、有符号的，以二进制补码表示的整数；
最小值是 -128（-2⁷）；
最大值是 127（2⁷-1）；
默认值是 0；
byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一；

例子：byte a = 100，byte b = -50。

short：

short 数据类型是 16 位、有符号的以二进制补码表示的整数
范围-32768（-2¹⁵）~ 32767（2¹⁵ - 1）；
默认值是0

int

int 数据类型是32位、有符号的以二进制补码表示的整数；
范围 -2,147,483,648（-2³¹）~ 2,147,483,647（2³¹ - 1）；
默认值0

long

long 数据类型是 64 位、有符号的以二进制补码表示的整数；
默认值0L
"L"理论上不分大小写，但是若写成"l"容易与数字"1"混淆，不容易分辩。所以最好大写。

float

float 数据类型是单精度、32位、符合IEEE 754标准的浮点数；
默认值0.0f
不能用来表示精确的值

double

double 数据类型是双精度、64 位、符合IEEE 754标准的浮点数；
默认值0.0d
同样不能表示精确的值

boolean

boolean数据类型表示一位的信息
默认值false
这种类型只作为一种标志来记录 true/false 情况

char

char类型是一个单一的 16 位 Unicode 字符
范围\u0000 ~\uffff（即65535）
char 数据类型可以储存任何字符

引用类型

在Java中，引用类型的变量非常类似于C/C++的指针。引用类型指向一个对象，指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型，比如 Employee、Puppy 等。变量一旦声明后，类型就不能被改变了。
对象、数组都是引用数据类型。
所有引用类型的默认值都是null。
一个引用变量可以用来引用任何与之兼容的类型。
例子：Site site = new Site(“Runoob”)。

java常量

常量在程序运行时是不能被修改的。
在 Java 中使用 final 关键字来修饰常量，声明方式和变量类似

final double PI = 3.1415927;
通常使用大写字母表示常量
当使用常量的时候，前缀 0 表示 8 进制，而前缀 0x 代表 16 进制

java转义字符序列

符号	字符含义
\n	换行 (0x0a)
\r	回车 (0x0d)
\f	换页符(0x0c)
\b	退格 (0x08)
\0	空字符 (0x20)
\s	字符串
\t	制表符
"	双引号
’	单引号
\	反斜杠
\ddd	八进制字符 (ddd)
\uxxxx	16进制Unicode字符 (xxxx)

自动类型转换

整型、实型（常量）、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算。

转换从低级到高级。

低  ------------------------------------>  高

byte,short,char—> int —> long—> float —> double

自动转化必须满足转换前的数据类型的位数要低于转换后的数据类型

实例变量

实例变量声明在一个类中，但在方法、构造方法和语句块之外；
当一个对象被实例化之后，每个实例变量的值就跟着确定；
实例变量在对象创建的时候创建，在对象被销毁的时候销毁；
实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息；
实例变量可以声明在使用前或者使用后；
访问修饰符可以修饰实例变量；
实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见；
实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定；
实例变量可以直接通过变量名访问。但在静态方法以及其他类中，就应该使用完全限定名：ObejectReference.VariableName

类变量（静态变量）

类变量也称为静态变量，在类中以 static 关键字声明，但必须在方法之外。
无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。
静态变量除了被声明为常量外很少使用。常量是指声明为public/private，final和static类型的变量。常量初始化后不可改变。
静态变量储存在静态存储区。经常被声明为常量，很少单独使用static声明变量。
静态变量在第一次被访问时创建，在程序结束时销毁。
与实例变量具有相似的可见性。但为了对类的使用者可见，大多数静态变量声明为public类型。
默认值和实例变量相似。数值型变量默认值是0，布尔型默认值是false，引用类型默认值是null。变量的值可以在声明的时候指定，也可以在构造方法中指定。此外，静态变量还可以在静态语句块中初始化。
静态变量可以通过：ClassName.VariableName的方式访问。
类变量被声明为public static final类型时，类变量名称一般建议使用大写字母。如果静态变量不是public和final类型，其命名方式与实例变量以及局部变量的命名方式一致。

java修饰符

访问修饰符

public : 对所有类可见。使用对象：类、接口、变量、方法
default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。
private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）

修饰符当前类同一包内子孙类(同一包) 子孙类(不同包) 其他包
public Y Y Y Y Y
protected Y Y Y Y/N（说明） N
default Y Y Y N N
private Y N N N N

修饰符	当前类	同一包内	子孙类(同一包)	子孙类(不同包)	其他包
`public`	Y	Y	Y	Y	Y
`protected`	Y	Y	Y	Y/N（说明）	N
`default`	Y	Y	Y	N	N
`private`	Y	N	N	N	N

私有访问修饰符-private

私有访问修饰符是最严格的访问级别，所以被声明为 private 的方法、变量和构造方法只能被所属类访问，并且类和接口不能声明为 private。

受保护的访问修饰符-protected

protected 需要从以下两个点来分析说明：

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

访问控制和继承

父类中声明为 public 的方法在子类中也必须为 public。
父类中声明为 protected 的方法在子类中要么声明为 protected，要么声明为 public，不能声明为 private。
父类中声明为 private 的方法，不能够被继承。

非访问修饰符

static 修饰符，用来修饰类方法和类变量。

final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。

abstract 修饰符，用来创建抽象类和抽象方法。

抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充
如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。
抽象类可以包含抽象方法和非抽象方法

抽象方法

抽象方法是一种没有任何实现的方法，该方法的的具体实现由子类提供。

抽象方法不能被声明成 final 和 static。

任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。

如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。

synchronized 和 volatile 修饰符，主要用于线程的编程。

synchronized 关键字声明的方法同一时间只能被一个线程访问。
synchronized 修饰符可以应用于四个访问修饰符。
volatile 修饰符

volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
一个 volatile 对象引用可能是 null。

java异常

在常见类中有介绍

重写(Overriding)和重载(Overloading)

重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。

例如：父类的一个方法申明了一个检查异常 IOException，但是在重写这个方法的时候不能抛出 Exception 异常，因为 Exception 是 IOException 的父类，只能抛出 IOException 的子类异常。

重写规则

参数列表必须完全与被重写方法的相同。
返回类型与被重写方法的返回类型可以不相同，但是必须是父类返回值的派生类（java5 及更早版本返回类型要一样，java7 及更高版本可以不同）。
访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为 public，那么在子类中重写该方法就不能声明为 protected。
父类的成员方法只能被它的子类重写。
声明为 final 的方法不能被重写。
声明为 static 的方法不能被重写，但是能够被再次声明。
子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为 private 和 final 的方法。
子类和父类不在同一个包中，那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法。
重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
构造方法不能被重写。
如果不能继承一个方法，则不能重写这个方法

重载

重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。

每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。

最常用的地方就是构造器的重载。

被重载的方法必须改变参数列表(参数个数或类型不一样)；
被重载的方法可以改变返回类型；
被重载的方法可以改变访问修饰符；
被重载的方法可以声明新的或更广的检查异常；
方法能够在同一个类中或者在一个子类中被重载。
无法以返回值类型作为重载函数的区分标准。

重写与重载之间的区别

区别点	重载方法	重写方法
参数列表	必须修改	一定不能修改
返回类型	可以修改	一定不能修改
异常	可以修改	可以减少或删除，一定不能抛出新的或者更广的异常
访问	可以修改	一定不能做更严格的限制（可以降低限制）

java 多态

多态存在的三个必要条件

继承
重写
父类引用指向子类对象

多态的实现方式

重写
接口
抽象类和抽象方法

比如：

Parent p = new Child();

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。

多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。


/**
 * @author 稀奇古怪
 *
 */
public class Test多态 {
	public static void main(String[] args) {
		  System.out.println("Show Cat:");
	      show(new Cat());  // 以 Cat 对象调用 show 方法
		  System.out.println("Show Dog:");
	      show(new Dog());  // 以 Dog 对象调用 show 方法
	      System.out.println("Test is begin:");
	      Animal a = new Cat();  // new Cat()对象向上转型 赋值给Animal 
	      a.eat();               // Animal类有抽象方法eat(),所以可以调用的Cat 的 eat
	      Cat c = (Cat)a;        // Animal a 向下转型 可以调用cat的方法  
	      c.work();        // 调用的是 Cat 的 work
	  }  
	            
	    public static void show(Animal a)  {
	      a.eat();  
	        // 类型判断
	        if (a instanceof Cat)  {  // 猫做的事情 
	            Cat c = (Cat)a;  
	            c.work();  
	        } 
	        else if (a instanceof Dog) { // 狗做的事情 
	            Dog c = (Dog)a;  
	            c.work();  
	        }  
	    }  
	}
	 
	abstract class Animal {  
	    abstract void eat();  
	}  
	  
	class Cat extends Animal {  
	    public void eat() {  
	        System.out.println("吃鱼");  
	    }  
	    public void work() {  
	        System.out.println("抓老鼠");  
	    }  
	} 
	  
	class Dog extends Animal {  
	    public void eat() {  
	        System.out.println("吃骨头");  
	    }  
	    public void work() {  
	        System.out.println("看家");  
	    }  
}

虚函数

虚函数的存在是为了多态。

Java 中其实没有虚函数的概念，它的普通函数就相当于 C++ 的虚函数，动态绑定是Java的默认行为。如果 Java 中不希望某个函数具有虚函数特性，可以加上 final 关键字变成非虚函数。

package 继承_多态

Salary.java

package 继承_多态;

public class Salary extends Employee{
	private double salary; // 全年工资
	   public Salary(String name, String address, int number, double salary) {
	       super(name, address, number);
	       setSalary(salary);
	   }
	   public void mailCheck() {
	       System.out.println("Salary 类的 mailCheck 方法 ");
	       System.out.println("邮寄支票给：" + getName()
	       + " ，工资为：" + salary);
	   }
	   public double getSalary() {
	       return salary;
	   }
	   public void setSalary(double newSalary) {
	       if(newSalary >= 0.0) {
	          salary = newSalary;
	       }
	   }
	   public double computePay() {
	      System.out.println("计算工资，付给：" + getName());
	      return salary/52;
	   }
//	   public int getNumber() {
//		  return (int)salary;
//	   }
}

Employee.java

package 继承_多态;

public class Employee {
	private String name;
	private String address;
	private int number;
   
	public Employee(String name, String address, int number) {
		System.out.println("Employee 构造函数");
		this.name = name;
		this.address = address;
		this.number = number;
		}
   
	public void mailCheck() {
		System.out.println("邮寄支票给： " + this.name 
				+ " " + this.address);
		}
	public String toString() {
		return name + " " + address + " " + number;
		}
	public String getName() {
		return name;
		}
	public String getAddress() {
		return address;
		}
	public void setAddress(String newAddress) {
		address = newAddress;
		}
	public int getNumber() {
		return number;
		}
}

VirtualDemo.java

package 继承_多态;
/*
 * 疑问:父类Employee具有私有变量number，name，address
 * 而子类Salary只有私有变量salary 
 * 子类实例化的时候给了参数number，name，address,salary（调用了父类的构造器）
 * 按道理说 子类不能拥有父类的number，name，address属性，只能有salary
 * 但是父类没有实例化，只有子类实例化了的
 * 那么此时的number，name，address变量值是存在父类里的嘛?
 * ？？？
 * 这个现象该怎么理解呢？
 * 
 * 其实每当调用子类构造器new一个子类对象的时候，都要先调用父类的构造new一个父类对象
 * 父类对象隐式的存在于子类中，子类是这样继承父类的变量和方法的
 * 
 * 子类构造器调用父类构造器的方式类似于递归，也就是说子类先调用父类，然后父类再调用它的父类
 * 以此类推一直到一个没有父类的类为止，最先用这个没有父类的类的构造器生成对象，再依次往子类方向生成对象。
 *
 *
 *子类不能继承父类的私有变量和私有方法
 *但是当继承的方法涉及父类的私有变量时，该方法可以使用该私有变量。
 *
 */
public class VirtualDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Salary s = new Salary("员工 A", "北京", 3, 3600.00);
	      Employee e = new Salary("员工 B", "上海", 2, 2400.00);
	      System.out.println("使用 Salary 的引用调用 mailCheck -- ");
	      s.mailCheck();
	      System.out.println("\n使用 Employee 的引用调用 mailCheck--\n");
	      e.mailCheck();
	      
//	      System.out.println(s.getNumber());
	}

}

例子解析：

实例中，实例化了两个 Salary 对象：一个使用 Salary 引用 s，另一个使用 Employee 引用 e。
当调用 s.mailCheck() 时，编译器在编译时会在 Salary 类中找到 mailCheck()，执行过程 JVM 就调用 Salary 类的 mailCheck()。
因为 e 是 Employee 的引用，所以调用 e 的 mailCheck() 方法时，编译器会去 Employee 类查找 mailCheck() 方法。
在编译的时候，编译器使用 Employee 类中的 mailCheck() 方法验证该语句，但是在运行的时候，Java虚拟机(JVM)调用的是 Salary 类中的 mailCheck() 方法。

以上整个过程被称为虚拟方法调用，该方法被称为虚拟方法。

Java中所有的方法都能以这种方式表现，因此，重写的方法能在运行时调用，不管编译的时候源代码中引用变量是什么数据类型。