Java SE——类与对象（1）

一、面向对象编程

1.面向对象编程特点：

（1）封装性：所谓封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。简而言之就是，内部操作对外部而言不可见(保护性)

（2）继承性：继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

（3）多态性：所谓多态就是指一个类实例的相同方法在不同情形有不同表现形式。多态机制使具有不同内部结构的对象可以共享相同的外部接口。

2.一些名词

OOA：面向对象分析

OOD：面向对象设计

OOP：面向对象编程

二、类与对象的定义

在进行类定义时先定义属性，再定义构造方法（没有返回值，与类名相同），最后再定义普通方法

类：类就是指共性的概念

对象：对象指的是一个具体的、可以使用的事物

1.定义一个类

类是由方法和属性组成的

2.定义一个对象

类名对象名=new 类名()；

3.对象内存分析

栈内存：存放的是局部变量（包含编译期可知的各种基本数据类型、对象引用-即堆内存的地址，可以简单的理解为对象的名称）,Java栈是与线程对应起来的，每当创建一个线程，JVM就会为这个线程创建一个对应的Java栈

堆内存：保存的是真正的数据。即对象的属性信息，只要有new，就是在堆上开辟空间

三、private实现封装处理

使用private对属性进行封装，要访问私有属性，按照java的设计原则必须提供 setter方法（主要用于进行属性内容的设置与修改）和getter方法（主要用于属性内容的取得）

使用private对属性进行封装特点：只允许本类访问，而不允许外部类访问

class Person
{
	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&&age<=100)
		{
			this.age = age;
		}
		else {
			this.age = 0;
		}
	}
	public void PrintMessage() {
		System.out.println("名字："+this.name+"年龄："+this.age);
		
	}
			
}
public class Test {	
	public static void main(String[] args) {
		Person person=new Person();
		person.setName("张三");
		person.setAge(11);
		person.PrintMessage();
		
	}
}

注：类中的所有属性都用private进行封装，若属性要被外部类进行访问时，必须要定义getter和setter方法

四、构造方法和匿名对象

构造方法就是使用关键字new实例化新对象时来进行调用的操作方法，对于构造方法的定义，需要遵循

1）方法名称必须与类名称相同
2）构造方法没有返回值类型声明
3）每一个类中一定至少存在一个构造方法（没有明确定义，则系统自动生成一个无参构造）

可以使用构造方法来对类中属性进行初始化操作

class Person
{
	private String name;
	private int age;
	public Person(String n,int a) {
		name=n;
		setAge(a);
	}
	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&&age<=100)
		{
			this.age = age;
		}
		else {
			this.age = 0;
		}
	}
	public void PrintMessage() {
		System.out.println("名字："+this.name+"年龄："+this.age);
		
	}
			
}
public class Test {	
	public static void main(String[] args) {
		Person person=new Person("张三",11);
		person.PrintMessage();
		
	}

五、this关键字

this关键字作用：

1）调用本类属性

2）调用本类方法

3）表示当前对象

1.this关键字调用本类属性

只要在类中方法访问类中属性，一定要加this关键字

2. this关键字调用本类方法

（1）this调用普通方法

class Person
{
	private String name;
	private int age;
	public Person(String name,int age) 
	{
		this.name=name;
		this.age=age;
		this.PrintChar();//this调用普通方法
		
	}
	public void PrintChar() //普通方法
	{
		System.out.println("**************");
	}
	public void Print() 
	{
		System.out.println("姓名："+this.name+"年龄"+this.age);
		
	}
}
public class Test {	
	public static void main(String[] args) 
	{
		Person person=new Person("张三", 11);
		person.Print();
	}
}

（2）this调用构造方法

注： this调用构造方法的语句必须在构造方法首行

class Person
{
	private String name;
	private int age;
	public Person()//无参构造
	{
		System.out.println("*****1*******");
	}
	public Person(String name)//有参构造
	{
		this();//调用本类的无参构造
		this.name=name;
	}
	public Person(String name,int age)//有参构造
	{
		this(name);//调用本类的有参构造
		this.name=name;
		this.age=age;
	}
	public void Print() {
		System.out.println("姓名："+this.name+"年龄"+this.age);
	}
}
public class Test {	
	public static void main(String[] args) {
		Person person1=new Person();
		Person person2=new Person("张三");
		Person person3=new Person("李四",11);
		person1.Print();
		person2.Print();
		person3.Print();
	}
}

（3）this表示当前对象

class Person
{
	public void Print() {
		System.out.println("1"+this);//this调用本类中的方法，this表示当前执行的对象
	}
}
public class Test {	
	public static void main(String[] args) {
		Person person1=new Person();
		System.out.println("2"+person1);
		person1.Print();
		System.out.println("************");
		Person person2=new Person();
		System.out.println("3"+person2);
		person2.Print();
		
	}
}

六、static关键字

1.static修饰属性

（1）访问static属性（类属性）应使用类名称.属性名

（2）所有的非static属性（实例变量）必须在对象实例化后使用，而static属性（类属性）不受对象实例化控制

2.static修饰方法

（1）所有的static方法不允许调用非static定义的属性或方法
（2）所有的非static方法允许访问static方法或属性

使用static定义方法的目的：某些方法不希望受到类的控制，即可以在没有实例化对象的时候执行

Java SE——类与对象（1）

猜你喜欢