2 面向对象

最新推荐文章于 2024-07-15 22:27:18 发布

灭掉c与java

最新推荐文章于 2024-07-15 22:27:18 发布

阅读量74

点赞数 1

分类专栏： java 文章标签： java 开发语言

本文链接：https://blog.csdn.net/laiyoumi/article/details/128371338

版权

java 专栏收录该内容

8 篇文章 1 订阅

订阅专栏

面向对象有三大特性：封装性，继承性，多态性。

如何分辨一个类呢？

类：有class的就是。

类中可以定义成员方法，成员变量。


class student{
	String name;
	int age;
	void read() {
		System.out.println("大家好我是"+name+"年龄"+age);
	}
}


public class Example02 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		student str=new student();//创建啦堆内存
		student str1=null;
		str1=str;//把str堆内存的使用权给拉str1，这个时候，堆内存里面的变量，两个都可以修改
		str.name="xiaohua";
		str.age=20;
		str1.age=50;
		str.read();
		str1.read();
		

	}

}

这个代码就是我自己打出来的，上面的student类里面可以定义成员方法read（），也可以定义成员变量：strin name；

在这里需要注意一个：局部变量和成员变量，局部变量实在成员方法里面的变量，它的优先级大于成员变量。他的作用域也就在成员方法里面。

对象的说明

声明一个对象：

类名+对象名。比如我在上面定义的student类，声明他的对象：

student stu；

这个时候他还没有子啊内存里面开辟空间，这个时候就要给他开辟空间：

stu=new student();

一般直接这样：

student stu=new student（）；

然后stu就有student类里面的所有方法，使用它的成员方法：
stu.read();

使用他的属性也类似。

对象的引用传递

引用如同c语言的指针。如下

class student{
	String name;
	int age;
	void read() {
		System.out.println("大家好我是"+name+"年龄"+age);
	}
}


public class Example02 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		student str=new student();//创建啦堆内存
		student str1=null;
		str1=str;//把str堆内存的使用权给拉str1，这个时候，堆内存里面的变量，两个都可以修改指向的内存空间的元素
		str.name="xiaohua";
		str.age=20;
		str1.age=50;
		str.read();
		str1.read();
		

	}

}

把代码打出来，运行看，就可以知道啦。

访问控制：

这个就是修饰符：

private：定义该成员只能在本类中访问。

default：只能在一个包里面的类之间访问。

如同这个：一个包就是src里面的一个单元，我这里有名叫：第二章练习。的包

protected:这个可以在本包，以及不同包之间的类使用，

public:范围更加大：可以在所有类里面访问。

封装性

为什么使用呢？

它是一个数据的保护屏障，防止本类中的代码和数据被外部程序随机修改。

实现封装：

在eclipse里面有一个快捷键：

alt+shift+s，就可以跳出一个窗口，找到这个窗口，点击里面有get与set关键字的选项，可以快速的调出各成员变量的get，set方法，

完成封装性，就需要在同一个包下面创建一个文件。

public class student01 {
	private String name;
	private int age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		
		if(age<0) {
			System.out.println("您的输入有无");
		}else {
			this.age = age;
		}
	}
	public void read() {
		System.out.println("大姐好"+name+"，年龄"+age);
	}
}

写上这些。

get（）方法就是为啦获取对应的值。

set方法就是为啦设置对应成员变量的值。

构造方法：

构造方法是一种特殊的方法，它是一个与类同名且没有返回值类型的方法。对象的创建就是通过构造方法来完成，其功能主要是完成对象的初始化。当类实例化一个对象时会自动调用构造方法。构造方法和其他方法一样也可以重载。

构造方法名与类名相同，且没有返回值，因为没有返回值，所以没有return返回一个值。

总结来说构造方法就是在new对象出来的时候给对象赋值。如下面的案例：

class student{
	private String name;
	private int age;
	public student(String n,int a) {
		super();
		// TODO Auto-generated constructor stub
		name=n;
		age=a;
	}   
	public void read() {
		System.out.println("我是"+name+"年龄"+age);
	}

}



public class Example06 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		 student str=new  student("张山",18);//在这里，new出啦一个对象，调用啦构造方法，就可以直接在括号里面赋值
		 str.read();

	}

}

构造函数的重载：

构造函数名字可以相同，但是形参列表可以不同，就可以利用这一点来给不同的构造方法赋值。

class student{
	private String name;
	private int age;
	
	public student() {	}
	
	public student(String n) {
		name = n;
	}

	public student(String n,int a) {
		super();
		// TODO Auto-generated constructor stub
		name=n;
		age=a;
	}   
	public void read() {
		System.out.println("我是"+name+"年龄"+age);
	}

}



public class Example06 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		 student str1=new  student("张山");//调用啦只有一个形参的构造方法
		 student str=new  student("张山",18);//调用了两个形参的构造方法
		 str1.read();
         str.read();
	}

}

注意点：当你没有创建构造方法时，系统会自动创建构造方法，这个构造方法没有代码，没有参数，他只是为啦能让你new一个对象而已。

因为要通过构造方法来实现想要的功能，所以写代码时，程序员会创建构造方法，来达成某一个功能，这个时候系统就不会自动创建构造方法啦。

接下来讲解this关键字：

他的作用就是：用来区分同名的局部变量和成员变量。

调用本类的构造方法~成员方法~本类中的属性。

使用方法：

调用本类中的属性：

class student {
	private String name;
	private int age;
	//定义构造方法
	public student(String name, int age) {
		this.name = name;
		this.age = age;
		//这里的name就是局部变量，用this指向对象的成员属性name，就是成员变量name。
	}
	public String read() {
		return  "大姐好"+name+"，年龄"+age;
	}
	
}



public class example10 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		student stu=new student("张山",18);
		System.out.println(stu.read());

	}

}

调用成员方法：

public String read() {
		return  "大姐好"+name+"，年龄"+age;
		this.student();
	}

类似上面的，student（）是一个普通的成员方法。

调用构造方法：

注意点：只能再构造方法中调用其他的构造方法，两个构造方法不能互相调用对方，使用this调用构造方法只可以放在第一行，且只能出现一次。使用方法：

public student() {
		this("zhangs",18);
		
	}

students是一个构造方法，这里的this是调用有两个形参变量的构造方法，括号里面没有参数就代表没有调用没有形参的构造函数。

代码块:普通代码块。

构造代码块：

class student {
	private String name;
	private int age;
	{
		System.out.println("大姐好"+name+"，年龄"+age);
	}
	//定义构造方法
	public student(String name, int age) {
		this.name = name;
		this.age = age;
		//这里的name就是局部变量，用this指向对象的成员属性name，就是成员变量name。
	}
	public student() {
		this("zhangs",18);
		
	}
	
}

在age成员变量下面，就只有一个代码块，当实例化对象的时候，先执行构造代码块的内用，在执行构造方法。

其他的代码块类型后面会讲解。

static关键字：

用它来修饰属性，可以让变量创建一个存储空间，所有的该类的对象对这个变量值进行修改，都是全部修改的，变量的话：它只可以用来修饰成员变量。

代码实例如下：

class student{
	String name;
	int age;
	static String school="a大学";
	
	public student(String name, int age) {
		this.name = name;
		this.age = age;
	}

	void read() {
		System.out.println("大家好我是"+this.name+"年龄"+this.age+school);
	}
}


public class Example02 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		student str=new student("zhangsan",18);//创建啦堆内存
		student str1=new student("z",18);
		student str3=new student("zhangsan",18);//还没对school属性修改值
		str.read();
		str1.read();
		str3.read();
		str3.school="bdaxue";//对student类里面的school修改值，则school子啊任何地方的值都是这个
		str3.read();

	}

}

用static修饰方法：

class student{
	//使用啦private，所以成员变量只能通过set方法来赋值，get方法获取值。这个实现啦封装的思想。
	private String name;
	private int age;
	private static String school="a大学";
	
	public student(String name, int age) {
		this.name = name;
		this.age = age;
	}

	void read() {
		System.out.println("大家好我是"+this.name+"年龄"+this.age+school);
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public static String getSchool() {
		return school;
	}
//使用啦static来修饰这个方法
	public static void setSchool(String school) {
		student.school = school;
	}
	
}


public class Example02 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		student str=new student("zhangsan",18);//创建啦堆内存
		student str1=new student("z",18);
		student str3=new student("zhangsan",18);//还没对school属性修改值
		str.read();
		str1.read();
		str3.read();
		student.setSchool("bxuexiao");//因为setschool方法使用啦static方法修饰，所以可以通过类名.方法名来调用它，不需要new出对象然后在用这个对象来调用它
		str3.read();

	}

}

静态代码块与构造代码块类似，只是在{}前面加拉static关键字修饰，他的优先级比构造代码块高。

一般使用它为成员变量赋初值，因为调用这个类之后，它只能执行一次。后面再调用它就不能啦。

以上的理论的东西，接下来我会分享练习的案例，有我的思路以及代码