JAVA笔记-面向对象(2)

基本介绍：

​ JAVA中允许用一个类中,多个方法存在,但要求形参列表不一致
好处:

1. 减轻了起名的麻烦
2. 减轻了记名的麻烦

方法重载使用细节:

1. 方法名：必须相同
2. 参数列表：必须不同(形参类型或者个数或顺序,至少有一样不同,参数名无要求)
3. 返回类型：无要求

class Met{
    //下面四个方法构成了重载
    public void calculate(int n1){
        return n1;
    }
    public void calculate(int n1,double n2){
        return n1+n2;
    }
    public void calculate(String n1){
        return n1;
    }
    public void calculate(double n1){
        return n1;
    }
}

总结

在一个类里面创建多个名字一样的方法，然后主方法去调用你创建的方法
虽然名字都一样，但是它会根据你输入的参数去寻找和形参列表里面类型一样的方法，然后输出

基本概念：

JAVA允许同一个类中多个同名同功能但参数不同的方法封装成一个方法就可以通过可变参数实现

基本语法:

问修饰符 返回类型 方法名(数据类型…形参名){
}

可变参数使用细节

1. 可变参数的实参可以为0或任意多个
2. 可变参数的实参可以为数组
3. 可变参数的本质就是数组
4. 可变参数可以和普通类型一起放在形参列表,但必须保证可变参数在最后
5. 一个形参列表中只能出现一个可变参数

public static void main(String[] args) {
    HspMetod hsp = new HspMetod();
	System.out.println(hsp.sum(5,100,10));
	hsp.n1(11,12,23,56,45);
}

class HspMetod{
	//int...表示接受的是可变参数,类型int,即可接收多个int(0-多)
	//使用可变参数时,可以当做数组来使用,即nums可以当做数组
	public int sum(int... nums) {
		//System.out.println("接收的参数个数="+nums.length);
		int res = 0;
		for(int i = 0;i
			res += nums[i];
		}
		return res;
	}
    public int[] n1(int... n2) {
		for(int i = 0;i
			System.out.println(n2[i]);
		}
		return n2;
	}
}

基本介绍：

1. 在JAVA编程中,主要的变量就是属性和局部变量

2. 我们说的局部变量一般是指在成员方法中定义的变量

3. JAVA中作用域的分类

   ​ 全局变量:也就是属性,作用域为整个类体

   ​ 局部变量:也就是除了属性之外的其他变量,作用域为定义它的代码块中

4. 全局变量可以不赋值,直接使用，因为有默认值,局部变量必须赋值后才能使用,因为没有默认值

public static void main(String[] args) {		
	Cat cat = new Cat();
	cat.cry();		
}
class Cat{
	//全局变量:也就是属性,作用域为整个类体
	//属性在定义时可以直接赋值
	//全局变量可以不赋值,直接使用，因为有默认值
	int age = 10;
	double weight;//有默认值0.0
	
	public void hi() {
		//局部变量必须赋值后才能使用,因为没有默认值
		//int num;
		//System.out.print("num="+num);
	}
	
	public void cry() {
		//1.局部变量一般是指在成员方法中定义的变量
		//2. n 和 name 就是局部变量
		//3. n 和 name 的作用域就在cry方法中(出了cry方法用不了)
		int n = 10;
		String name = "jack";
		System.out.println(n+name);
	}
	
	public void eat() {
		System.out.println("在eat中使用属性age="+age);
		//System.out.println("在eat中使用cry的变量 name="+name);
	}
}

作用域:注意事项和细节使用

1. 属性和局部变量可以重名,访问时遵循就近原则
2. 在同一作用域中,比如在同一个成员方法中,两个局部变量,不能重名
3. 属性生命周期较长,伴随着对象的创建而创建,伴随着对象的死亡而死亡
   局部变量生命周期较短,伴随着它的代码块的执行而创建
   伴随着代码块的结束而死亡,即在一次方法调用过程中
4. 作用域范围不同
   全局变量:可以被本类使用,或其他类使用(通过对象调用)
   局部变量:只能在本类中对应的方法中使用
5. 修饰符不同
   全局变量/属性可以加修饰符
   局部变量不可以加修饰符

public static void main(String[] args) {
		Person p1 = new Person();
		p1.say();//当执行say方法时,say方法的局部变量name会创建
		//执行完成后name局部变量就销毁,全局变量的name仍然可以使用
    
   		Son son = new Son();
		son.test(); //第一种跨类访问对象属性
		son.test2(per);//第二种跨类访问对象属性
}
class Person{
	String name = "jack";
	//属性和局部变量可以重名,访问时遵循就近原则
	public void say() {
		String name = "king";//如果注销输出就是Jack
		System.out.println("name="+name);//输出King
	}
}

class Per{
	//private int age = 10;属性可以加修饰符
	String name = "JOJO";
}

class Son{
	public void test() {
		//private int  age = 10;
		Per per = new Per();
		System.out.println("test="+per.name);
	}
	
	public void test2(Per p) {
		System.out.print("test2="+p.name);
	}
}

基本介绍：

1. 构造器是类的一种特殊的方法,它的主要作用是完成对新对象的初始化

特点:

1. 方法名和类名相同
2. 没有返回值
3. 在创建对象时,系统会自动的调用该类的构造器完成对象的初始化

基本语法：

[修饰符] 方法名(形参列表){
方法体;
}

class Arry{
    public Arry(){
        System.out.println("构造器");
    }
}

当我们new一个对象时,直接通过构造器指定名字

public static void main(String[] args) {		
		Arry p1 = new Arry("纳兹",17);
		System.out.println("p1对象的信息如下n"+"姓名="+p1.name+"n"+"年龄="+p1.age);
	}
}
//在创建人类对象时,直接指定这个对象的年龄和姓名
class Arry{
	String name;
	int age;
	//构造器
	//没有返回值,不能写void
	//构造器的名称和类Person一样
	//(String pName, int pAge) 是构造器的形参列表,规则和成员方法一样
	public Arry(String pName, int pAge) {
		System.out.println("构造器被调用~完成对象的属性初始化");//检查有没有被系统自动调用
		name = pName;
		age = pAge;
	}
}

构造器的使用细节：

1. 一个类可以定义多个不同的构造器,即构造器重载
2. 构造器名和类名相同
3. 构造器没有返回值
4. 构造器是完成对象的初始化,并不是创建对象
5. 在创建对象时,系统自动的调用该类的构造方法
6. 如果程序员没有定义构造方法,系统会自动给类生成一个默认无参构造方法,比如:Dog(){} 使用javap指令反编译查看
7. 一旦定义了自己的构造器,默认的构造器就被覆盖了,就不能再使用默认的无参构造器,除非显示的定义一下,即:Dog(){}

class Cywl{
	String name;
	int age;
	//第一个构造器
	public Cywl(String cName,int cAge) {
		name = cName;
		age = cAge;
	}
	//第二个构造器
	public Cywl(String cName) {
		name = cName;
	}
	//第三个构造器,构造器重载
	public Cywl(int cAge) {
		age = cAge;
	}
}
//如果程序员没有定义构造方法,系统会自动给类生成一个默认无参构造方法
//使用javap指令反编译查看
class Dog{
	String name;
	
	Dog(){
		//显示的在定义一下,无参构造器
	}
}

总结

1. 构造器的修饰符可以默认
2. 构造器没有返回值
3. 方法名和类名必须一样
4. 参数列表和成员方法一样的规则
5. 构造器的调用,由系统完成

public static void main(String[] args) {
		//this关键字:java虚拟机会给每个对象分配this,代表当前对象
		//总结:那个对象调用,this就代表那个对象
		JoJo jojo =  new JoJo("乔纳森",20);
		jojo.info();
		//System.out.println(jojo.hashCode());	
	}
}

class JoJo{
	//成员变量
	String name;
	int age;
	public JoJo(String name,int age) {
		//this.name就是当前对象的属性name
		this.name = name;
		//this.age就是当前对象的属性age
		this.age = age;
		//System.out.println(this.hashCode());
	}
		
	//成员方法
	public void info() {//输出对象的属性
		System.out.println(name+"t"+age);
	}
}

this关键字使用细节

1. this关键字可以用来访问本类的属性,方法,构造器
2. this用于区分当前类的属性和局部变量
3. 访问成员方法的语法：this.方法名(参数列表);
4. 访问构造器语法：this(参数列表)，注意只能在构造器中使用
5. this不能在类定义的外部使用,只能在类定义的方法中使用

class Dou{
	String name = "jack";
	int age = 18;
	//访问成员方法的语法:this.方法名(参数列表);
	public void f1() {
		System.out.println("乔纳森");
	}
	public void f2() {
		System.out.println("迪奥");
		//调用本类的f1方法
		//第一种方式
		f1();
		//第二种方式
		this.f1();
		//在继承的时候,讲这两种方法的不同
	}
	public void f3() {
		String name = "smith";
		//传统方式
		System.out.println("name="+name+"tage="+age);//按照就近原则访问
		//使用this
		System.out.println("name="+this.name+"tage="+this.age);//明确访问属性
	}
}

访问构造器语法：this(参数列表)

注意只能在构造器中使用

	public Dou(){
		this("赛迦",10000);//必须放在第一条语句
		System.out.println("迪迦");
		//在这里访问public Dou(String name,int age)构造器
	}
	public Dou(String name,int age){
		System.out.println("Dou(String name,int age)");
	}