【Java】学习笔记二

类

Java中对象的方法以成员方法的形式存在，对象的属性以成员变量的形式存在。对象的属性也称为成员变量，成员变量可以是任意类型，整个类中均是成员变量作用范围
为书添加书名属性

public class book{
	private String name;
	public String getName(){
		return name;
	}
	public void setName(String name){
		this.name = name;
	}
}

定义类需要使用关键字class

成员方法

定义成员方法的语法

权限修饰符[public | private] 返回值类型[void | String .. ] 方法名(参数类型 参数名){
	方法体
	return
}

关键字void可以使Java代码中的成员方法无返回值
成员方法中定义的变量为局部变量
如果一个方法中含有与成员变量同名的局部变量，则方法中对这个变量的方位以局部变量进行。

权限修饰符

• public：可以在任何地方被访问。
• protected：可以被子类访问，以及同一包中的其他类访问。
• 默认（无修饰符）：同一包中的其他类可以访问，但子类和不同包中的类不能访问。
• private：只能在当前类内部被访问。

局部变量

在成员方法内定义的变量，称为局部变量
局部变量在方法被执行时创建，在方法执行结束时被销毁
局部变量在使用时必须进行赋值操作或被初始化，否则会出现编译错误

交换两个整数的值：

public class changenumber{
	public static int[] exchange(int[] arr){
		int tmp = arr[0];
		arr[0] = arr[1];
		arr[1] = tmp;
		return arr;
	}
	public static void main(String args[]){
		int arr[] {17, 29};
		System.our.println("first number = "+arr[0]+", the second number = "+arr[1]);
		arr = exchange(arr);
		System.out.println("first number = "+arr[0]+", the second number = "+arr[1]);
	}
}

2. 非访问控制修饰符：
   • static：表示静态成员，属于类本身而不是实例。
   • final：表示不可更改的常量或不可继承的类或方法。
   • abstract：只能用于抽象类和抽象方法，表示没有实现的方法定义或无法实例化的类。
   • synchronized：用于并发编程，同一时间只能由一个线程访问的代码块。
   • volatile：用于并发编程，表示变量在多个线程之间可见。
   • transient：表示不会被序列化的成员变量。
   • native：表示使用其他语言编写的本地方法。
   • strictfp：用于浮点数计算的精确性和一致性。

this

在Java中，this 关键字类似于Python中的 self 关键字。this 和 self 都指向类中的当前对象或实例。

在Java中，this 是对当前类实例的引用。它通常用于区分实例变量和局部变量，或者用于引用当前类的方法或构造函数。例如，this.variableName 引用当前对象的实例变量 variableName。

同样，在Python中，self 是一个惯例上使用的参数名，它指向类的实例。它在类方法中用于访问当前实例的属性和方法。例如，self.variableName 引用当前对象的实例变量 variableName。

this 和 self 都用于区分实例变量和局部变量，并访问当前实例的成员。尽管Java和Python的语法和命名习惯不同，但 this 和 self 的概念和目的是相似的。

构造方法

在类中，除成员方法外，还存在一种特殊类型的方法，那就是构造方法。构造方法是一个与类同名的方法，对象的创建就是通过构造方法完成的。每当类实例化一个对象时，类都会自动调用构造方法。
在定义一个构造方法时，构造方法没有返回值，但这与普通没有返回值的 方法不同，普通没有返回值的方法使用public void methodex()的形式，而构造方法并不需要使用void
只有在类中没有定义任何构造方法时，编译器才会在该类中自动创建一个不带参数的构造方法。

public Book(){
	//构造方法体
}

例子

public class eggcake{
	int eggcount;
	public eggcake(int eggcount){
		this.eggcount = eggcount;
	}
	public eggacke(){
		this(1);
	}
	public static void main(String args[]){
		eggcake cake1 = new eggcake();
		System.out.println("cake1.eggcount: "+cake1.eggcount);
		eggcake cake2 = new eggcake(2);
		System.out.println("cake2.eggcount: "+cake2.eggcount);
}

静态变量和静态方法

静态变量和静态方法由关键字static修饰， 被声明为static的变量和方法被称为静态成员。静态成员属于类所有，区别于个别对象，可以在本类或其他类使用类名和.运算符来调用静态成员

类名.静态类成员

例子

public class staticdemo{
	static double pi = 3.14;  //在类中定义静态变量
	public static void method(){    //在类中定义静态方法
		System.out.println("this is static method");
	}
	public static void main(String args[]){
		System.out.println(staticdemo.pi); //调用静态变量
		staticdemo.method();  //调用静态方法
}

静态变量与静态方法的作用通常是为了提供共享数据或方法，如数学计算公式等。

public class cust{
	static int count = 0;
	String name;
	public cust(String name){
		this.name = name;
		count++;
	}
	public static void main(String args[]){
		cust c1 = new cust("tom");
		System.out.println("i am"+c1.name);
		cust c2 = new cust("jerry");
		System.out.println("i am"+c2.name);
	}
}

可以使用static定义一个静态区域，称为静态代码块。当类文件被执行时，首先执行static块中的程序，并且只会执行一次，语法如下：

public class example{
	static {

	}
}

类的主方法

主方法是类的入口点，它定义了程序从何处开始。
主方法的语法如下：

public static void main(String[] args){

}

• 主方法是静态的，所以如果直接在主方法中调用其他方法，则该方法必须也是静态的
• 主方法没有返回值
• 主方法的形参为数组。其中args[0] - args[n]分别代表程序的第一个参数到第n个参数，可以使用args.length获取参数的个数
  读取主方法的参数值

public class maindemo{
	public static void main(String[] args){
		for (int i = 0; i <args.length; i++){
			System.out.println(args[i]);
		}
	}
}

通过命令args.length可返回参数的个数

对象

类实质上就是封装对象属性和行为的载体，而对象则是类抽象出来的一个实例。
类是分装对象的属性和行为的载体，反过来说，具有相同属性和行为的一类实体称为类
·
面向对象程序设计具有以下特点：封装性、继承性、多态性

• 封装性：将对象的属性和行为封装起来，其载体就是类，避免了外部操作对内部数据的影响
• 继承性：比如鸽子类与鸟类具有许多相同的特性，因此鸽子类继承鸟类可以节省很多定义工作，被继承的类称为父类或超类

对象的创建

通过new来创建对象，每实例化一个对象就会自动调用一次构造方法，实质上这个过程就是创建对象的过程。
test是对象分配空间的引用

Test test = new test();
Test test = new test("a);

例子，

public class People{
	String name;
	int age;
	String sex;
	public People(){  //无参数的构造方法
	}
	public People(String name, int age, String sex){
		this.name = name;
		this.age = age;
		this.sex = sex;
	}
	public static void main(String[] args){
		People p1 = new People("tom", 23, "boy");
		People p2 = new People("lily", 19, "girl");
		System.out.println(p1+"\n"+p2);
	}
}

访问对象的属性

使用new创建对象后，可以使用对象.类成员来获取对象的属性和行为

public class dog{
	String name;
	String color;
	String voice;
	public dog(String name, String color, String voice){
		this.name = name;
		this.color = color;
		this.voice = voice;
	}
	public void call(){
		System.out.println(voice);
	}
	public static void main(String[] args){
		dog d1 = new dog("maomao", "white","wuwuwu");
		System.out.println(d1.name+" the color is  "+d1.color); //访问对象的属性
		d1.call(); //访问对象的行为
	}
}