Java基础语法(9)-面向对象之类的成员

title: java基础语法(9)-面向对象之类的成员

blog: csdn

data: java学习路线及视频

1.面向过程与面向对象

1. 面向过程(pop) 与 面向对象(oop)

• 二者都是一种思想，面向对象是相对于面向过程而言的。面向过程，强调的是功能行为，以函数为最小单位，考虑怎么做。面向对象，将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。

• 面向对象更加强调运用人类在日常的思维逻辑中采用的思想方法与原则，如抽象、分类、继承、聚合、多态等。

  • 面向对象的三大特征

    ​ 封装 (encapsulation)

    ​ 继承 (inheritance)

    ​ 多态 (polymorphism)

2. 面向过程

3. 面向对象

4. 面向对象的思想概述

• 程序员从面向过程的执行者转化成了面向对象的指挥者
• 根据问题需要，选择问题所针对的现实世界中的实体。
• 从实体中寻找解决问题相关的属性和功能，这些属性和功能就形成了概念世界中的类
• 把抽象的实体用计算机语言进行描述，形成计算机世界中类的定义。即借助某种程序语言，把类构造成计算机能够识别和处理的数据结构。
• 将类实例化成计算机世界中的对象。对象是计算机世界中解决问题的最终工具。

2.类和对象

1. 面向对象的概述

• 类(class)和对象(object)是面向对象的核心概念。
• 类是对一类事物的描述，是抽象的、概念上的定义
• 对象是实际存在的该类事物的每个个体，因而也称为实例(instance)。
• “万事万物皆对象” (女朋友)

2. 类的语法格式

修饰符 class  类名 {
	属性声明;
	方法声明;
}
说明：修饰符public：类可以被任意访问类的正文要用{  }括起来

public class person{
	private int age ;	//声明私有变量 age 
	public void showage(int i) { //声明方法showage( )
		age = i;
 	}
}

3.对象的创建和使用

1. 创建对象语法

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

animal xb=new animal();

2. 对象的使用

对象名.对象成员的方式访问对象成员（包括属性和方法）

3. java中的类和对象

//animal类
public class animal {
	public int legs; 
	public void eat(){
		system.out.println(“eating.”);
	}
	public viod move(){ 
		system.out.println(“move.”);
}

public class zoo{
	public static void main(string args[]){
		//创建对象
		animal xb=new animal();
		xb.legs=4;//访问属性 
		system.out.println(xb.legs);
		xb.eat();//访问方法
		xb.move();//访问方法
	}
}

4.类的成员之一: 属性

1. 语法格式

修饰符 数据类型 属性名 = 初始化值 ;

• 说明1: 修饰符
  • 常用的权限修饰符有：private、缺省、protected、public 其他修饰符：static、final (暂不考虑)
• 说明2: 数据类型
  • 任何基本数据类型(如int、boolean) 或 任何引用数据类型。
• 说明3：属性名
  • 属于标识符，符合命名规则和规范即可。

public class person{
	private int age;	//声明private变量 age
	public string name = “lila”;	//声明public变量 name
}

2. 变量的分类：成员变量与局部变量

class person{
	//1.属性
	string name;//姓名--成员变量 
	int age = 1;//年龄
	boolean ismale;//是否是男性 
	
	public void show(string nation){
						//nation:局部变量 
	string color;//color:局部变量
	color = "yellow";
	}
}
 
//测试类
class persontest{
public static void main(string[] args){
	person p = new person(); 
	p.show(“usa”);
	}
}

3. 对象属性的默认初始化赋值

5.类的成员之二: 方法

1. 什么是方法(method、函数):

• 方法是类或对象行为特征的抽象，用来完成某个功能操作。在某些语言中也称为函数或过程。
• 将功能封装为方法的目的是，可以实现代码重用，简化代码
• java里的方法不能独立存在，所有的方法必须定义在类里。

public class person{ 
	private int age;
	public int getage()  { //声明方法getage()
		return age;
 	}
	public void setage(int i) {      //声明方法setage
		age = i;	//将参数i的值赋给类的成员变量age
	}
}

2. 方法的声明格式：

修饰符 返回值类型 方法名（参数类型 形参1, 参数类型 形参2, ….）{
	方法体程序代码
	return 返回值;
}

修饰符：public,缺省,private, protected等

3. 方法的分类

	无返回值	有返回值
无形参	void 方法名（）{}	返回值的类型 方法名（）{}
有形参	void 方法名（形参列表）{}	返回值的类型 方法名（形参列表）{}

4. 注意

   • 方法被调用一次，就会执行一次
   • 没有具体返回值的情况，返回值类型用关键字void表示，那么方法体中可以不必使用return语句。如果使用，仅用来结束方法。
   • 定义方法时，方法的结果应该返回给调用者，交由调用者处理。
   • 方法中只能调用方法或属性，不可以在方法内部定义方法。

5. 方法的重载

   • 在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

   • 与返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参数类型)。调用时，根据方法参数列表的不同来区别。

//返回三个整数的和
int add(int x,int y,int z){
	return x+y+z;
}

6. 方法中的可变个数形参

• 声明格式：方法名(参数的类型名 ...参数名)
• 方法参数部分指定类型的参数个数是可变多个：0个，1个或多个
• 可变个数形参的方法与同名的方法之间，彼此构成重载
• 可变参数方法的使用与方法参数部分使用数组是一致的
• 方法的参数部分有可变形参，需要放在形参声明的最后
• 在一个方法的形参位置，最多只能声明一个可变个数形参

//可变参数
public void test(string a,int... b){
  	for (int i : b) {
       log.i("test:","b:" + i);
     }
}

6.类的成员之三: 构造器

1. 构造器的特征
   • 它具有与类相同的名称
   • 它不声明返回值类型。（与声明为void不同）
   • 不能被static、final、synchronized、abstract、native修饰，不能有return语句返回值
2. 构造器的作用
   • 创建对象；给对象进行初始化

person p = new person(“peter”,15);

3. 语法格式

修饰符	类名 (参数列表) {
	初始化语句；
}

//创建animal类的实例
//调用构造器，将legs初始化为4。
public class animal { 
	private int legs;
	// 构造器
	public animal() {
		legs = 4;
	}
	public void setlegs(int i) {
		legs = i;
	}
	public int getlegs() { 
		return legs;
}

4. 注意
   • java语言中，每个类都至少有一个构造器
   • 默认构造器的修饰符与所属类的修饰符一致
   • 一旦显式定义了构造器，则系统不再提供默认构造器
   • 一个类可以创建多个重载的构造器
   • 父类的构造器不可被子类继承

7.类的成员之四: 代码块

1. 代码块的作用：

   • 对java类或对象进行初始化

2. 代码块的分类:

   • 一个类中代码块若有修饰符， 则只能被static修饰，称为静态代码块(static block)，没有使用static修饰的，为非静态代码块

3. 静态代码块：用static修饰的代码块

   • 可以有输出语句。
   • 可以对类的属性、类的声明进行初始化操作。
   • 不可以对非静态的属性初始化。即：不可以调用非静态的属性和方法。
   • 若有多个静态的代码块，那么按照从上到下的顺序依次执行。
   • 静态代码块的执行要先于非静态代码块。
   • 静态代码块随着类的加载而加载，且只执行一次。

4. 非静态代码块：没有static修饰的代码块

   • 可以有输出语句。
   • 可以对类的属性、类的声明进行初始化操作。
   • 除了调用非静态的结构外，还可以调用静态的变量或方法。
   • 若有多个非静态的代码块，那么按照从上到下的顺序依次执行。
   • 每次创建对象的时候，都会执行一次。且先于构造器执行。

   class person {
   	public static int total; 
   	static {
   		total = 100;
   		system.out.println("in static block!");
   	}
   }
   
   public class persontest {
   	public static void main(string[] args) 
   	{ 
   		system.out.println("total = " + person.total); 
   		system.out.println("total = " + person.total);
   	}
   }
   

5. 程序中成员变量赋值的执行顺序

8.类的成员之五: 内部类

1. 内部类概念

• 当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构最好使用内部类。
• 在java中，允许一个类的定义位于另一个类的内部，前者称为内部类，后者称为外部类。
• 内部类的名字不能与包含它的外部类类名相同；

2. 分类

• 成员内部类（static成员内部类和非static成员内部类）
• 局部内部类（不谈修饰符）、匿名内部类

3. 成员内部类作为类的成员的角色

• 和外部类不同，inner class还可以声明为private或protected；
• 可以调用外部类的结构
• inner class 可以声明为static的，但此时就不能再使用外层类的非static的成员变量；

4. 成员内部类作为类的角色

• 可以在内部定义属性、方法、构造器等结构
• 可以声明为abstract类 ，因此可以被其它的内部类继承
• 可以声明为final的
• 编译以后生成outerclass$innerclass.class字节码文件（也适用于局部内部类）

5. 注意

• 非static的成员内部类中的成员不能声明为static的，只有在外部类或static的成员内部类中才可声明static成员。
• 外部类访问成员内部类的成员，需要“内部类.成员”或“内部类对象.成员”的方式
• 成员内部类可以直接使用外部类的所有成员，包括私有的数据
• 当想要在外部类的静态成员部分使用内部类时，可以考虑内部类声明为静态的

class outer {
	private int s;
	public class inner { 
		public void mb() {
		s = 100;
		system.out.println("在内部类inner中s=" + s);
	}
}
public void ma() {
	inner i = new inner();
	i.mb();
	}
}
public class innertest {
	public static void main(string args[]) {
	outer o = new outer();
	o.ma();
	}
}

9.结语

2020-3-31: java基础语法(6)-注释

2020-3-31: java基础语法(7)-数组

• 今日好文推荐

  • 一篇文章掌握整个jvm，jvm超详细解析！！！

• 今日资料推荐

  • 我的java自学之路