Java基础课总结

Ch 3面向对象基础

---

---

文章目录

• Ch 3面向对象基础
• 前言
• 一、预备知识
• 二、类与对象
  • 1.类
  • 2.对象
• 三、方法
  • 1.方法
  • 2.方法的重载
• 四、封装
  • 1.定义
  • 2.注意
  • 3.this
• 五、静态成员和对象数组
  • 1.静态
  • 2.继承

---

前言

本节只汇总了部分知识点，仅做重点参考.

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、预备知识

面向对象的三大特征：封装、继承、多态.

二、类与对象

1.类：

       定义了一种新的数据类型，是具有相同特征（属性）和共同行为（方法）的一组对象的集合.

  语法结构如下：

访问符  修饰符 class 类名{
            属性
            方法

}

public class way {

}

2.对象

（1）创建对象：类名 对象名=new 类名（）； 例：student ZS=new student（）；

（2）访问对象的属性：对象名.属性名；

（3）调用对象的方法：对象名.方法名（）.

三、方法

1.方法：  

（1）注意：先定义后使用；方法不调用，自己不执行；方法之间是并列的关系.

（ 2）方法的调用 ：方法名（）；

（3）方法的定义（声明方法）： public static void 方法名() {  }.

以下先给出一些基本用法，后给出一个简单实例：

package thuesday;
public class way {
	public static void main(String[] args) {	
		//（1）随便一个方法
		suibian();
		//（2）两个数想加的方法
		add(4,5);
		//（3）有返回值的方法
		int numa=add1(4,5);
		System.out.println(numa);
		//(4)两个小数之和
		double numb=add2(4.1,5.4);
		System.out.println(numb);
		//(5)一个小数和一个整数之和
		double numc=add3(4,5.4);
		System.out.println(numc);
	}	
		//1.方法的定义（声明方法）
		public static void suibian() {
		System.out.println("这是随便定义的一个方法");
	}
		
		//2.有参的方法使用
		public static void add(int a,int b) {// 公开 静态  无返回值  方法名（无参）
			int sum=a+b;//a=4 b=5
			System.out.println("sum的值为："+sum);	
		}
		
		//3.有返回值的方法
		public static int add1(int e,int f) {// 有返回值将void改为int
			int sum=e+f;//
			return sum;
}
		//4.一个整数和一个小数之和
		public static double add2(int h,double j) {// 小数型的将int改成double
			double sum=h+j;
			return sum;
}
}

//No 1class
package practice001;
public class  Student{//没有主函数不执行，当Test中主函数执行到Student时再调用它的属性
	//属性
	String name;//姓名
	int age;//年龄
	//方法
	public void speak() {
		System.out.println("大家好，我是"+name+"我今年"+age+"岁了");
}
	
}
//NO 2实现
package class_feizhaung;
import practice001.Student;
    public class Test_private {
	public static void main(String[] args) {
		//对象创建  实例化对象
		private001 onlyone=new private001();
		onlyone.name="唯一";
		//onlyone.age=21;
		//方法调用
		onlyone.setAge(-17);//括号里的是实参  实参给形参age1单向传值
		onlyone.speak();
		
	}
}

2.方法的重载：  

（1）定义：方法名称相同，方法参数的个数或者类型不同.以实际数据自动选择相应的方法.
（2）方法的重载会出题，简答题或者程序题

package thuesday;
public class way_reload {
	        public static void main(String[] args) {
		add(3,4);
	}	
			public static int add (int a,int b) {
				int sum=a+b;//
				return sum;
	}		
	        public static double add(double a,double b,double c) {
				double sum=a+b+c;
				return sum;
	}	
			public static double add(int a,double b) {
				double sum=a+b;
				return sum;			
}
}

四、封装

1.定义：不想外界随意的进行修改，关键字是private ；

2.注意：private修饰的变量或方法只能在本类中进行访问；

package class_feizhaung;
	public class private001 {
		//属性
		String name;//姓名
		private int age;//年龄封装，外界不能改变  age是全局变量
		
		public int getAge() {
			return age;
		}
		public void setAge(int age1) {//age1是局部变量  只在大括号里有效  age1是形参
			if (age1>0) {
			this.age=age1;//规定this修饰的是全局变量  如果把this删掉则age选择就近变量的age1
		}else {
			System.out.println("年龄错了");
		}
	}
		//方法
				public void speak() {
					System.out.println("大家好，我是"+name+"我今年"+age+"岁了");
		  }
}

3.this：用来区别同名的成员变量与局部变量（this.成员变量）.

public class This {
	String name;
	int age;
	public This() {
		//3.this关键字可以调用构造方法
		//使用this调用方法的时候必须放在方法的第一行
		//this(12,"haha")
	}
	public This(int age,String name) {
		//1.this关键字修饰的变量是全局变量
		this.age=age;
		this.name=name;
		//2.this关键字可以调用本类的方法
		this.speak();
	}
	public void speak() {
		System.out.println("大家好,我是"+name+"我今年"+age+"岁了");
	}
}

五、静态成员和继承

1.静态：

（1）注意：静态内容是优先于对象存在，只能访问静态，不能使用this/super。

（2）定义：public static final 数据类型 变量名=值；

public class Static01 {
		//static关键字 静态变量 静态方法 静态代码块
			public static void main(String[] args) {
				 Static01 onlyone=new Static01();
				 onlyone.name="唯一";
				 onlyone.schoolName="德州学院";
						//类名.属性名   调用 
						 Static01.schoolName="";	 
		}
}

2.继承：

（1）在程序中，如果想声明一个类继承另一个类，需要使用extends关键字

（2）用super继承父类的属性.

（3）重写：子类中出现与父类一样的方法时，会出现覆盖操作，也称为override重写、复写或者覆盖. 

（4）Object是所有类的直接或者间接父类，如果没有显示的说明，这个类继承Object

//父类
package afternoon;
	public class father {
	//属性
		String name;
	    int age;
	//方法
	public void shout() {
		System.out.println("儿子好，我是你的好爸爸");
	}

}

//子类
package afternoon;
	//JAVA只支持单继承 一个类只能有一个父亲，但是一个父类可以有多个子类
public class son extends father{
	//重写： 前提是继承，子类对继承到父类的内容进行修改
	//要求和父亲有相同的方法名、参数列表和返回值类型，子类的访问范围要大于等于父类的访问范围
	@Override
	public void shout() {
		//1.用super关键字调用父类的属性和方法
		super.shout();
		System.out.println("爸爸好，我是你的好儿子");
		//2.用super关键字可以调用父类的构造方法
		//使用super关键字可以调用构造方法时，只能放在构造方法的第一行，不能和this同时使用
		//super();
	}
}

//test
package practice001;
public class Test {
	public static void main(String[] args) {
		//对象创建  实例化对象
		Student onlyone=new Student();
		onlyone.name="唯一";
		onlyone.age=21;
		//方法调用
		onlyone.speak();
		//再创建一个对象
		Student only=new Student();
		only.name="只有";
		only.age=20;//如果不给新创建的对象年龄赋值，那运行结果会显示年龄为0（整型的默认值0)
		//再次调用speak方法
		only.speak();
		
	}

}