JavaSE Day08
JavaSE Day08 重载 和 构造方法
目录
java中的注释
- 单行
- 多行
- 文档注释javadoc，为javadoc命令识别的；可以生成帮助文档；
在idea中使用javadoc，Tools ---> generate javadoc；
-encoding utf-8 -charset utf-8
![-w380]()
package day8;
package day8;
/**
* 书类
*/
class Book {
/**
* 名称
*/
private String title;
/**
* 页数
*/
private int pageNum;
/**
* 名称的写访问器
*
* @param title 设置书的名称
*/
public void setTitle(String title) {
this.title = title;
}
/**
* 名称的读访问器
*
* @return 返回书的名称
*/
public String getTitle() {
return title;
}
/**
* 页数的写访问器
*
* @param pageNum 设置页数的值
*/
public void setPageNum(int pageNum) {
if (pageNum >= 200) {
this.pageNum = pageNum;
} else {
System.out.println("输入错误,页数不能少于200页");
this.pageNum = 200;
}
}
/**
* 页数的写访问器
*
* @return 返回页数
*/
public int getPageNum() {
return pageNum;
}
/**
* 显示名称 和 页数
*
* @return 名称 和 页数
*/
public String show() {
return this.title + "," + this.pageNum;
}
}
/**
* Book的测试类
*/
public class TestBook {
/**
* 测试类 主方法
*/
public static void main(String[] args) {
Book b1 = new Book();
b1.setTitle("java");
b1.setPageNum(50);
System.out.println(b1.show());
b1.setPageNum(250);
System.out.println(b1.show());
}
}
一个文件中定义多个类：
- 只能有一个public类，
- 包含主方法的类是public
- public所修饰的类的名字与文件名必须一致；
方法参数传递
- 值类型参数，基本数据类型
- 值不会受影响
- 引用类型参数
- 两个引用指向了同一个对象：值改变
- 两个引用指向不同的对象：值不变
package day8;
class Param {
int value;
}
class B {
}
public class TestParam {
public void f1(int n) {
n = 22;
}
public void f2(Param p){
p.value =22;
}
public void f3(Param p){
p = new Param();
p.value = 22;
}
public static void main(String[] args) {
TestParam t = new TestParam();
// 1. 值
int n = 11;
t.f1(n);
System.out.println(n);
// 2. 引用
Param p = new Param();
p.value = 11;
t.f2(p);
System.out.println(p.value);
//3.引用
Param p1 = new Param();
p1.value =11;
t.f3(p1);
System.out.println(p1.value);
}
}
可变参数--jdk5.0 提出的
- 语法 :
… - 底层是数组；
- 好处：传参的形式灵活；
- 位置：只能放再所有参数的最后；
可变参数 和数组参数的区别
- 数组作为参数 传参时只能传数组类型；
可变参数 可以传数组，可以是一个值，可以是多个值，也可以不传值； - 数组参数：可以有多个数组参数
可变参数 只能有一个 - 数组参数，可以放在任何位置
可变参数 只能放再所有参数的最后
不同类型的可变参数，也只能有一个
package day8;
public class TestDemo1 {
public int sum(int... args) {// 如果写成数组，那么在传参数的时候，参数也必须是数组；
// 而写成... 则实参的类型可以不是数组；
int sum = 0;
for (int i = 0; i < args.length; i++) {
sum += args[i];
}
return sum;
}
public int[] reverseArr(int[] arr) {
int[] arr1 = new int[arr.length];
for (int i = arr.length -1 ,j=0; i >=0 ; i--,j++) {
arr1[j] = arr[i];
}
return arr1;
}
public static void main(String[] args) {
TestDemo1 t = new TestDemo1();
int sum = t.sum(11, 22, 33, 44, 55);
System.out.println(sum);
int[] m = {11,22,33,44,55};
int[] m1 = t.reverseArr(m);
for (int a:m1
) {
System.out.println(a);
}
}
}
主方法传参
- public权限最大的
- Static 静态的
- Main 主方法，jvm调用；
- 用双引号引起来的表示一个参数；否则按照空格来区分参数的个数；
![-w452]()
封装
隐藏对象的属性和类中的实现细节，对外只提供公共的访问方式；
好处：
- 安全
- 方法中，可以有流程控制语句，控制数据的范围；
- 只能用提供的公共的访问方式访问；
访问器语法；（间接读）
-
读
Public 类型 get属性名(){ return 值； } -
写
public void set属性名(类型 变量名){ this.属性 = 变量; } -
可以在set方法中定义逻辑判断；
-
所以属性的值可以控制；（星号数量的作业）
this
- 当前类对象
- 作用
- 可以调用 本类成员；
- 区分同名的成员变量和局部变量；
- 调用本类构造器，
this([参数]); - 位置：
- 构造器中
- 构造器的第一行代码处；
方法重载
通常是在一个类中，方法名相同；参数列表不同（类型、个数、顺序）；与返回值无关；
package day8;
public class TestOVerload1 {
public void f(byte n){
System.out.println("byte");
}
public void f(short n){
System.out.println("short");
}
public void f(int n){
System.out.println("int");
}
public void f(long n){
System.out.println("long");
}
public void f(float n){
System.out.println("float");
}
public void f(double n){
System.out.println("double");
}
// public void f(int n1,double n2){
// System.out.println("intdouble");
// }
public void f(double n1,int n2){
System.out.println("doubleint");
}
// 不能根据返回值对方法进行重载；
// public double f(double n1,int n2){
// return 22.2;
// }
public static void main(String[] args) {
TestOVerload1 t = new TestOVerload1();
t.f(11);// int
t.f((byte)11);// byte
t.f(11L);// long
t.f(11.1);// double
t.f(11.1F);// float
t.f(11,22);
//t.f(11,22);// 自动类型转换，导致编译器不知道转换为那个方法；
}
}
作用：
方便记忆
package day8;
public class TestOVerload1 {
public void f(byte n){
System.out.println("byte");
}
public void f(short n){
System.out.println("short");
}
public void f(int n){
System.out.println("int");
}
public void f(long n){
System.out.println("long");
}
public void f(float n){
System.out.println("float");
}
public void f(double n){
System.out.println("double");
}
// public void f(int n1,double n2){
// System.out.println("intdouble");
// }
public void f(double n1,int n2){
System.out.println("doubleint");
}
// 不能根据返回值对方法进行重载；
// public double f(double n1,int n2){
// return 22.2;
// }
public static void main(String[] args) {
TestOVerload1 t = new TestOVerload1();
t.f(11);// int
t.f((byte)11);// byte
t.f(11L);// long
t.f(11.1);// double
t.f(11.1F);// float
t.f(11,22);
//t.f(11,22);// 自动类型转换，导致编译器不知道转换为那个方法；
}
}
可变参数的重载：
- 可变参数 和数组是一回事，不能重载
- 调用int，为了代码的兼容（优先调用基础数据类型）
- 传参的值对于多个方法都适合时，编译提示出错；
package day8;
public class TestOverload3 {
// 可变参数和数组是一回事，不能重载
// public void f(int[] n){
// System.out.println("int[]");
// }
// 2.调用int，为了代码的兼容
public void f(int n){
System.out.println(n);
}
public void f(int... n){
System.out.println("int...");
}
// 3.传参的值对于多个方法都适合，编译提示出错；
public void f(String... s){
System.out.println("String");
}
public void f(TestOverload3... t){
System.out.println("TestOverload3");
}
public static void main(String[] args) {
TestOverload3 t = new TestOverload3();
t.f(11);// 可变参数是5.0之后才出现的，为了代码的兼容一定调用int
String s = null;
//System.out.println(s.equals("abc"));
TestOverload3 t3 = null;
t.f(s);
t.f(t3);
//t.f(null);
// null 可以给所有引用类型赋值，所以编译器不知道给那个方法传值；
}
}
构造方法
语法：
访问修饰符 构造方法名(参数列表){
//初始代码；
}
分类：
- 默认构造器。
- 在定义类时，我们没有显示定义构造器，那么编译器会自动创建一个默认构造器；默认构造器是无参的，访问修饰符与类相同；
- 注意：只要在类中显示定义了构造器，那么默认构造器就不存在了
- 无参的
- 带参数的
作用：
- 初始化对象；
给对象的成员变量分配空间并赋值； - 注意：
- 名字与类名一致
- 不能定义任何的返回值类型；
- 调用：只有在创建对象 new时调用；
package day8;
class Person{
private int age;
private String sex;
// ---------------------------
// 无参构造；
public Person(){
//System.out.println("无参构造");
this.age = 22;
this.sex = "男";
}
//
public Person(int age,String sex){
this.age = age;
if(sex.equals("男") || sex.equals("女")){
this.sex = sex;
} else{
System.out.println(this.age + "输入错误");
this.sex = "男";
}
}
// ---------------------------
//间接赋值 访问器 写访问器
public void setAge(int age) { // int age = 22；
if(age >= 0 && age <= 150) {
this.age = age; // this.age = 22；
} else{
System.out.println("赋值出错了，必须0-150之间");
this.age = -1;
}
}
public void setSex(String sex) {
if("男".equals(sex)||"女".equals(sex)) {
this.sex = sex;
} else{
System.out.println("赋值出错，只能是男和女；");
this.sex = "男";
}
}
public String getSex() {
return this.sex;
}
// 访问器 读访问器
public int getAge() {
return this.age;
}
public String show(){
return age + "," + sex;
}
// 公共的 pulic 权限最大，所有人都能够调用；
// 私有的 private 访问级别最低；只能在定义他们的类中可见；
}
public class TestPerson {
public static void main(String[] args) {
// 调用过了 构造方法；构造器的访问权限与类的访问权限一样；
Person zhangsan = new Person();
Person lisi = new Person(33,"a");
/*zhangsan.setAge(22);
System.out.println();
zhangsan.setSex("男");
System.out.println(zhangsan.show());*/
}
}
构造方法重载
package day8;
class Role {
private String name;
private int age;
private String sex;
private String job;
// 声名处初始化
private String address = "内蒙古";
// 构造块 解决构造方法初始化 代码冗余的问题
{
address = "内蒙古";
}
public Role() {
this.name = "匿名";
//this.address = "内蒙古";
}
public Role(String job) {
// 调用本类构造方法
this();
this.job = job;
}
public Role(String sex, int age, String job) {
this(job);
this.sex = sex;
this.age = age;
}
public Role(String name, int age, String sex, String job, String address) {
this(sex, age, job);
this.name = name;
// this.address = address;
}
public String show() {
return name + "," + age + "," + sex + "," + job + "," + address;
}
}
public class TestRole {
public static void main(String[] args) {
Role person = new Role();
System.out.println(person.show());
Role killer = new Role("杀手");
System.out.println(killer.show());
Role monk = new Role("男", 80, "扫地");
System.out.println(monk.show());
Role qiaofeng = new Role("乔峰", 22, "男", "丐帮帮主", "西安");
System.out.println(qiaofeng.show());
}
}
构造块
class 类{
{
构造块
作用：解决多个构造器重载时；
代码冗余问题
执行：在创建对象时执行，
先执行构造块；
后执行构造器。
}
}
package day8;
class Employee{
// private int no;
// private String name;
private int age = 11;
{
age = 22;
// System.out.println("我是构造块");
}
public Employee(){
// System.out.println("我是构造器");
age = 33;
}
public int getAge() {
return age;
}
}
public class TestEmployee {
public static void main(String[] args) {
Employee emp = new Employee();
System.out.println(emp.getAge());
}
}
成员变量初始化过程
- 默认初始化 数据类型的默认值
- 按照代码执行顺序（从上到下）
主要看 声明处，构造块的位置 - 最后执行构造器；
构造方法 和访问器的区别
- 构造器 在创建对象new的时候完成初始化；对象创建完了，值都有了
访问器，在创建对象之后调用赋值； - 构造器 在创建对象new的时候 可以一次性给所有的成员变量初始化；
访问器，只能一个一个的赋值； - 构造器 只能完成赋值，在创建对象后修改成员变量的值；
访问成员变量的值，只能用访问器；
构造器 和普通方法的区别
- 构造器 就是为对象初始化的
- 普通方法是为了完成特定功能的；
- 构造器 只能在创建对象的时候才能调用；
- 普通方法用对象去调用；
浙公网安备 33010602011771号