超详解什么是类与对象及一些关键字的使用（Java）

类与对象（Java）

一、什么是面向对象？：是现在最为流行的软件设计与开发方法

1.它是一种模块化的设计模式
2.特点：封装性、继承性和多态性
3.那么什么是？
封装性：规定了不同级别的可见性的访问权限
继承性：派生类（子类）继承了超类（父类）的所有内容，并相应的增加了一些自己新的成员
多态性：允许程序中出现重名现象 如----方法重载/对象多态

二、什么是类？：类是由成员属性和方法组成的

1.实际上成员属性就是变量，方法就是一些操作行为（在C里面方法叫做函数）

class Person{           //定义一个类
	String name;       //【成员属性】人的姓名
	int age;		   //【成员属性】人的年龄
	public String getname(){	//获取name的属性内容
		return name;
	}
	public int getage(){	//获取age的属性内容
		return age;
	}
	public void tell(){
		System.out.println("姓名: " + name + "年龄： " + age); //输出
	}
}

三、什么是对象？：对象表示的是一个个独立的个体，对象的所有功能必须由类定义

1.对象需要通过关键字new来分配内存空间才能使用
2.通过实例化对象可以进行类操作

class Person{           //定义一个类
	String name;       //【成员属性】人的姓名
	int age;		   //【成员属性】人的年龄
	public String getname(){	//获取name的属性内容
		return name;
	}
	public int getage(){	//获取age的属性内容
		return age;
	}
	public void tell(){ //输出函数
		System.out.println("姓名: " + name + "年龄： " + age); 
	}
}

public class JavaDemo{	//通过实例化对象进行类操作
	public static void main(String args[]){
		Person per = new Person();	//声明并实例化对象，其实也就是说给对象per分配了一块堆内存的空间来保存该类中的成员属性
		per.name = "张三";
		per.age = 18;
		per.tell();
	}
}

四、对象内存是怎样分配的？：对象名称----栈内存、具体信息—堆内存

五、引用传递？：每一块栈内存都会保存有堆内存的信息，并且只允许保存一个堆内存的地址信息

这里有一点继承的意思在里面，通过引用传递，可以使新的对象保存旧的对象里面堆内存的信息，同时旧的对象也可以使用堆内存信息

public class JavaDemo{	//通过实例化对象进行类操作
	public static void main(String args[]){
		Person per1 = new Person();	//声明并实例化对象，其实也就是说给对象per分配了一块堆内存的空间来保存该类中的成员属性
		per1.name = "张三";
		per1.age = 18;
		Person per2 = per1;	//引用传递（有一点C里面赋值的意思在里面）
		per2.age = 80;
		per1.tell();	//通过引用传递可以改变堆内存中保存的信息，这时再输出对象per1的年龄则变为80了
	}
}

六、什么是成员属性封装？：只能通过方法来改变，封装内的属性/或实例化对象

class Person{           //定义一个类
	private String name;       //【成员属性】人的姓名
	private int age;		   //【成员属性】人的年龄
	public void setname(String tempname){	//设置name的属性
		name = tempname;
	}
	public void setage(int tempage){	//设置age的属性
		age = tempage;
	}
	public String getname(){	//获取name的属性内容
		return name;
	}
	public int getage(){	//获取age的属性内容
		return age;
	}
	public void tell(){ //输出函数
		System.out.println("姓名: " + name + "年龄： " + age); 
	}
}

public class JavaDemo{	//通过实例化对象进行类操作
	public static void main(String args[]){
		Person per = new Person();	//声明并实例化对象，其实也就是说给对象per分配了一块堆内存的空间来保存该类中的成员属性
		/*下面要设置类的属性必须要调用方法，因为与之前不同，类的成员属性都加了封装*/
		per.setname ("张三");
		per.setage (18);
		per.tell();
	}
}

七、什么是构造方法与匿名对象？：完成对象属性的初始化操作（这样即便没有栈内存的指向操作，也可以使用一次该对象，同样的由于没有栈内存的指向操作，所以该对象使用一次后就将成为垃圾空间）而有了构造方法后就可以在堆内存开辟的同时进行对象实例化处理

class Person{
	private String name;
	private int age;
	/*Person的构造方法，可以对成员属性进行初始化，但如果还需要对成员属性进行修改或获取则还需要定义 setter 和 getter 方法 ，这里偷个懒省略了，上面有类似，一般都是要加上的*/
	public Person(String tempname,int  tempage){
		name = tempname;
		age = tempage;
	}
	/*输出方法*/
	public void tell(){ 
		System.out.println("姓名: " + name + "年龄： " + age); 
	}
}
public class JavaDemo{
	public static void main(String args[]){
		Person per = new Person("张三",18);	//声明并实例化对象（但其实也可以不声明直接实例化对象，这就是匿名对象了）
		/*如：new Person("张三"，18).tell 这样代码就简洁了许多，直接一步到位了，但是这种没有指向对象的实例化操作，不好对该类进行后续的操作*/
		per.tell();
	}
}
			

八、什么是this关键字？：它表示当前对象的属性和方法

事实上不加this也可以调用类中的属性和方法，但是类中成员属性和方法参数由于表示含义的需要，有可能会产生重名定义的问题。类中的this会随着执行对象的不同而表示不同的实例
注意：如果一个类中存在了多个构造方法的，并且这些构造方法都使用了this（）相互调用，那么至少保留一个构造方法没有调用其他构造，以作为程序的出口

九、简单的Java类需要具备哪些条件？

1.类的名称一定要有意义，可以明确的描述某一类事物
2.类中的所有属性都必须使用pravite进行封装，封装后的属性必须提供setter(),getter()方法
3.类中可以提供有无数多个的构造方法，但是必须要保留无参构造方法
4.类中不允许出现任何的输出语句，所有内容的获取必须返回
5.【可选】可以提供一个获取对象的详细的信息的方法，可以将此方法设置为getInfo()

/*定义一个描述部门的简单的Java类*/
class Dept {					//满足第一点类的名称是“部门”的英文，可以明确描述某一类事物
	private long deptno;
	private String dname;
	private String loc;
	/*以上满足第二点类中的所有属性都使用了pravite进行了封装*/
	public Dept(){};				//满足了第三点提供了无参构造方法
	public Dept(long deptno,String dname,String loc){	//通过this来调用成员属性，就不用再在构造方法的参数上想新的名字了，这样代码会更简洁易读
		this.deptno = deptno;
		this.dname = dname;
		this.loc = loc;
	}
	public String getIofo(){
		return "【部门信息】部门编号：" + this.deptno + "、部门名称：" + this.dname + "、部门位置：" + this.loc;		//满足第四个条件类中所有内容的获取都用的是返回 
	}
	//setter(),getter()方法省略
}

public class JavaDemo{
	public static void main(String argc[]){
		Dept dept = new Dept(10,"技术部","北京");	//实例化例的对象
		System.out.println(dept.getIofo());		// 获取对象的信息
	}
}

程序执行结果：

十、什么是static关键字？：用于全局属性和全局方法的声明

1.如果想要类中的属性定义为公共属性（所有对象都可以使用的属性），则可以在声明属性前加上static光键字，而当有一个对象修改了static属性内容后，将会影响到所有的对象
2.static的定义方法？：可以在没有实例化对象的情况下直接调用static定义的属性和方法。static结构可以不受到，对象实例化的限制，并且可以实现多个实例化对象的共享操作
3.应用案例：对在通过调用进行对象实例化的过程中，可以通过static关键字对对象的个数进行累加处理

class Chinese{
	private String name;
	private int age;
	static String country = "中华人民共和国";
	public Chinese(String name,int age){
		this.name = name;
		this.age = age;
	}
	//setter(),getter() 省略
	public String getInfo(){
		return "姓名：" + this.name + "、年龄：" + this.age + "、国家：" + this.country ;
	}
}

public class JavaDemo{
	public static void main(String argc[]){
	Chinese perA = new Chinese("张三",18);
	Chinese perB = new Chinese("李四",19);
	Chinese perC = new Chinese("王五",20);
	perA.country = "伟大的中国";//因为country为static属性，当对象perA修改country后，对象preB和preC的country也会跟着被修改
	System.out.println(perA.getInfo());
	System.out.println(perB.getInfo());
	System.out.println(perC.getInfo());
	}
}
/*本程序定义了一个描述中国人的类Chinese，类中country为static（公共属性），即该属性会保存在全局数据当中，当有一个对象修改了static属性内容后将会影响到其他的所有对象*/

程序执行后的结果：

十一、什么是代码块？：使用 { } 定义起来的一段程序

1.什么是普通代码块？：将一个方法中的代码进行分割
2.什么是构造代码块？：将一个代码块定义在一个类中（每一次实例化新的对象都会调用构造块）
3.什么是静态代码块？：如果一个构造代码块上使用了Static关键字进行定义的话，那么该代码块就表示静态代码块（静态代码块会优先与构造代码块执行，并且静态代码块中的代码只会执行一次）

十二、小结

1.面向对象的程序设计是现在主流的程序设计方法，他有三大主要特性：分装性、继承性、多态性
2.类与对象的关系：类是对象的模板，对象是类的实例（特别注意类只能通过对象才能使用）
3.**类的组成？😗*成员属性、方法
4.对象的实例化格式：类名称 + 对象名称 = new + 类名称（） （new用于堆内存空间的开辟）
5.如果一个对象没有被实例化而直接调用，则使用时会空指向异常（如果是用static关键字定义的，可以被调用一次）
6.类属于引用数据类型，进行引用传递时，传递的是堆内存的使用权（这句话很重要，之前讲引用传递的时候，绕来绕去，都是这些东西，即一块堆内存可以被多个栈内存所指向，而一块栈内存只能保存一块堆内存的地址）
7.类的封装性：通过pravite关键字进行修饰，被封装的属性不能被外部直接调用，而只能通过setter或getter()f方法完成。只要是属性，类中属性必须全部封装
8.构造方法可以为类中的属性进行初始化，构造方法与类的名称相同，无返回值，无类型声明，有封装。如果在类中没有明确定义出构造方法，则自动生成一个无参的什么都不做得构造方法。构造方法可以重载但必须至少有一个
9.在Java中使用this关键字可以表示当前的对象，可以调用本类中的属性，但调用时要求要放在构造方法的首行
10.使用static声明的属性和方法可以直接由类名称调用，static属性是所有对象共享的，所有对象都可以对其进行操作

小小温馨提示：码字不易，希望能一键三连哦🤞🤞🤞