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
}
//this调用本类构造方法
class Person{
private String name;
private int age;
public Person() {
System.out.println("**************");
}
public Person(String name) {
this();//调用本类中的无参构造
this.name=name;
}
public Person(String name,int age) {
this(name);//调用本类中的有参构造
this.age=age;
}
}
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 只有本类可以访问
浙公网安备 33010602011771号