Java基础 之二 类和对象

1.基础概念

1) 概念

简单来说，类是具有相同特征事物的抽象，比如有轮子的都可以抽象为车；对象则可以看做类的具体实例，比如创建一个法拉利的车，就是车这个类的实例。

抽象、封装、继承、多态是类的四个特点

2) 类之间的关系

• 依赖

依赖就是一种"uses a"关系。
比如订单类需要用到账户类的一些属性。
所以说，如果一个类的方法操纵另一个类的对象，我们就说一个类依赖于另一个类。
一般而言，依赖关系在Java中体现为局域变量、方法的形参，或者对静态方法的调用。

• 关联

被关联类B以类属性的形式出现在关联类A中，或者关联类A引用了一个类型为被关联类B的全局变量的这种关系，就叫关联关系。
比如在Java中，关联关系一般使用成员变量来实现。

• 聚合

聚合是关联关系的一种特例，他体现的是整体与部分、拥有的关系，即has-a的关系
public class Family {
    private List<Child> children; //一个家庭里有许多孩子

    // ...
}
在关联关系中，类AB之间没用必然的联系，比如员工类中有属性自行车，但是聚合关系中是拥有的关系，比如家庭里有孩子，但是这种关系也不是必然拥有的。
聚合关系意味着A类对象包含着B类对象

• 继承

继承是一种"is-a"的关系，表示特殊与一般的关系。
比如说水果类是父类，柚子类是子类，它是水果类的一种扩展，拥有额外的属性和方法。

3) 构造器

//构造器就是与类同名的函数，作用就是初始化类的对象的属性。
    public class Employee{
        private String name;
        private Double salary;
        private LocalDate hireDay;
    }
	//没有void
    public Employee(String n,double s,int year,int month,int day)
    {
		name = n;
    	salary = s;
    	LoacalDate hireDay = LocalDAte.of(year,month,day);
    }
	Employee employee = new Employee("James",20000,1890,1,1);

需要注意的是

1.构造器与类同名
2.每个类可以有多个构造器，构造器可以有0个或1个或多个参数
3.构造器没有返回值
4.构造器总是和new一起用

4) this

//看这个方法
public void raiseSalary(double byPercent){
	double raise = salary * byPercent/100;
	salary = raise
}
//调用
james.raiseSalary(50);
/*
	raiseSalary这个方法有两个参数
	1.byPercent是显式参数
	2.this,是隐式参数，代表调用此方法的那个对象
*/
//相当于
public void raiseSalary(double byPercent){
	double raise = this.salary * byPercent/100;
	this.salary = raise
}

5) 封装的优点

类中的属性都是private域，这样封装可以防止外界轻易修改这些属性
若想修改属性，就可以像4中那样在类中写一个修改的方法。

若一个类中包含下面三项
1.私有的数据域
2.公有的域访问器方法 getter
3.公有的域更改器方法 setter
这个类可以叫做bean

6) 基于类的访问权限

一个方法可以访问所属类的所有对象的私有数据！

2.静态域和静态方法

1) 静态域

class Employee{
	private static int companyId ;
}
/*
	Employee类的所有对象共享companyId域，
	静态域属于类，而不属于任何独立的对象

*/

2) 静态常量

//静态变量使用的比较少
//静态常量使用的多
public class Math{
    ...
    public static final double PI = 3.1415926535897;
    ...
}

//System.out out也是System类中的静态常量
public static final PrintStream out = ...;

//final 修饰的域不能被修改

3) 静态方法

/*
	静态方法是没有this的方法,因为它不能访问非静态实例域，因为它不能操作对象，它在对象被创造前已经初始化
	静态方法可以访问自身类中的静态域
*/
class Employee{
    private static int companyId ;
	public static int getcompanyId(){
        return companyId;
    }
}
//直接用类名调用
int n = Employee.getcompanyId();

4) main

main方法也是静态方法，它不对任何对象进行操作
事实上，在启动程序时还没有任何一个对象。静态的main方法将执行并创建程序所需要的对象。

3.方法参数（值传递）

/*
    先说重点：Java语言是值传递，方法形参得到的是所有实参的拷贝
    众所周知，方法的参数有两种类型
    1.基本数据类型
    2.引用类型
 */

//举例1 基本数据类型
public static void tripleValue(double x){
	x = 3*x;
	System.out.println(x);	//输出30
}
double value = 10;
tripleValue(value);
System.out.println(value);	//输出10
/*
	实际上是把value的值复制了一份给x,而全程在方法中操作x,和value无关
*/

//举例2 引用类型
public static void function(Employee x){
	x.raiseSalary(20000);	//Employee中的方法
}
harry = new Employee(...);
function(harry);
//此时harry的工资涨了20000

/*
	你可能会疑问 不是值传递吗，怎么还会改变原来的对象值？
	实际上，这里还是值传递，只不过引用类型传递的是引用对象的地址值的拷贝
	所以harry把它所指向对象的地址拷贝给x
	然后harry和x就指向同一个对象，自然就修改了该对象
	这里的值传递是引用的对象地址值的拷贝
*/

4.重载 重写

先介绍一下重载和重写

1.方法重载：
在同一个类中保持方法名相同，参数的类型或数量不同，返回值可以相同也可以不同。
拓展：方法签名是由方法名和参数列表构成，也就是说返回值以及访问修饰符不算方法签名，方法签名可以唯一确定类中的一个函数。
所以重载就是方法名相同，参数列表不同的函数，和返回值以及访问修饰符无关。

2.方法重写：
子类重写父类的某一函数，保证函数名、参数都一样，返回值的类型要小于父类方法的返回值类型；
抛出异常类型的范围要小于父类抛出异常的类型；
子类函数访问权限大于父类。
父类private的方法不能被继承，也就不存在重写。

5.对象构造

1) 默认初始化

//若构造器中没有显式的赋初值，那么域就会被赋为默认值：数值为0、布尔值为false、对象引用为null
Employee e = new Employee();

2) 无参构造器

//示例
public Employee(){
	name = "";
	salary = 0;
	hireDay = LocalDate.now();
}

说明：
1.若编写类中无构造器，系统会提供一个默认的无参构造器，所有的值设置为默认值；
2.若类中提供了至少一个构造器，但是没有无参构造器，则在构造对象的时候不提供参数被视为不合法;

3) 有参构造器的参数名

public Employee(String aName,double aSalary){
	name = aName;
	salary = aSalary;
}

public Employee(String name,double salary){
	name = name;
	salary = salary;
}
/*
	1.为了保证可读性,一眼就看懂参数，可以在变量名前加一个a
	2.或者将参数名和数据域同名，用this表示是对象的域

*/

4) 调用另一个构造器

public Employee(double aSalary){
    this("Jack",aSalary)	//调用3中的两个参数的构造器
}

5) 初始化块

三种初始化数据域的方法
1.利用有参构造器
2.直接在声明时赋值
3.初始化块

//只要构造类的对象，这些块就会被指向
//构造对象时，先执行块，再执行构造器
class Employee{
    private static int nextId;	//从0开始
    private int id;	//员工id
    {
        id = nextId;
       	nextId++;
    }
}

//也可以用静态块初始化静态域
static{
    	Random generator = new Random();
       	nextId = generator.nextInt(10000);//赋予一个小于10000的随机值
      }

6) finalize

可以为任何一个类添加finalize方法
finalize将再垃圾回收器清楚对象之前调用
但是实际上，很难知道finalize方法什么时候才能调用，用的不好还会影响GC性能，少用

6.包

Sun公司建议将公司的因特网域名的倒序作为包名，对于不同的项目用不同的子包
com.tyy.demo1
con.tyy.demo2

1)类的导入

//一个类可以使用所属包中的所有类，以及其他包中的公有类
//两2种方式访问另一个包的公有类
//方式1
    java.time.LocalDate today = java.time.LocalDate.now();

//方式2
	import java.util.*;
	LocalDate today = LocalDate.now();
//需要注意
//只能使用*导入一个包，而不能用import java.*或者import java.*.*导入以java为前缀的所有包

2) 静态导入

//import还可以导入静态方法和静态域
import static java.lang.System.*;
//就可以使用System类的静态方法和静态域
out.println("GoodBye world");	//省略了System.

3) 将类放入包中

pakage com.tyy.demo
public class Employee{
	.....
}
//如果没有在源文件中写pakage语句，这个源文件的类就被放在一个默认包中，默认包是一个没有名字的包

4) 包作用域

如果没有指定public或private，这个部分(类、方法或变量)可以被同一个包中所有方法访问

5) 类路径

jar包包含了多个.class文件

类路径是所有包含类文件路径的集合 就是.class文件

在dos下编译java程序，就要用到classpath这个概念，尤其是在没有设置环境变量的时候。
classpath就是存放.class等编译后文件的路径。

javac：如果当前你要编译的java文件中引用了其它的类(比如说：继承)，但该引用类的.class文件不在当前目录下，这种情况下就需要在javac命令后面加上-classpath参数，通过使用以下三种类型的方法 来指导编译器在编译的时候去指定的路径下查找引用类。

(1).绝对路径：javac -classpath c:/junit3.8.1/junit.jar   Xxx.java
(2).相对路径：javac -classpath ../junit3.8.1/Junit.jar  Xxx.java
(3).系统变量：javac -classpath %CLASSPATH% Xxx.java (注意：%CLASSPATH%表示使用系统变量CLASSPATH的值进行查找，这里假设Junit.jar的路径就包含在CLASSPATH系统变量中)

7.文档注释

文档注释是/** ... */

1) 类注释

类注释必须放在import之后，类定义之前

2) 方法注释

@param 变量描述
@return 返回值描述
@throws 抛出异常描述

3) 域注释

/**
	the "Hearts" card suit
*/
public static final int Hearts;

4) 通用注释

@author 姓名 可以使用多个
@version 版本
@since 堆引入特性的版本描述
@deprecated 这个标记对类、方法、变量、添加一个不再使用的注释
@see 引用

8.访问权限

public 			所有的类都可以访问
protected 		本包、所有子类可以访问
default			本包可以访问
private 		只有本类可以访问