java基础三（面向对象、java的三大特性）

---

1、面向对象

面向对象的定义：面向对象(Object Oriented)是软件开发方法，一种编程范式。面向对象的概念和应用已超越了程序设计和软件开发，扩展到如数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。面向对象是一种对现实世界理解和抽象的方法，是计算机编程技术发展到一定阶段后的产物。
面向对象是相对于面向过程来讲的，面向对象方法，把相关的数据和方法组织为一个整体来看待，从更高的层次来进行系统建模，更贴近事物的自然运行模式

面向对象和面向过程的区别：
面向对象是相对于面向过程的，面向过程是强调的功能行为，现象对象是将功能封装进对象，强调的是具备功能的对象

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

1.1类

类和对象的概念：类是具有相同特性的的实物的抽象描述，类是抽象的，概念性的，
可以理解为汽车设计图纸就是类，而实际的汽车就是我们类的实例，具体的对象 ，
对象是实实在在存在的具体事物，万事万物皆对象

//类的定义
修饰符 class 类名{
	类的属性声明
	类的方法声明
} 
注意：
1、修饰符有4种---public protected 缺省 private，访问权限由大到小
2、class 必须要写
3、类名每个单词的首字母要大写

1.2 对象

使用new +构造器创建一个新的对象；
使用“对象名.对象成员”的方式访问对象成员（包括属性和方法）

1.3 类的成员（属性、方法、构造器）

类的属性和方法

/*类的属性声明---语法格式：
修饰符 类型 属性名 = 初始值；
注意：
1、修饰符private:该属性只能由该类的方法访问。
2、修饰符public:该属性可以被该类以外的方法访问。    
3、类型：任何基本类型，如int、boolean或任何类
*/
public class Student{
	public String name = "哈里波特";//公共的名字属性
	private int age = 28;//私有的年龄属性
	protected char gender;
	double weight;
}

/*
类的方法---语法格式：
修饰符 返回值类型 方法名（参数列表）{
	方法体
	……
}
注意：
1、返回值类型 void表示无返回值，数据类型：当前方法可以通过return 值返回对应数据类型的值
2、方法的调用--同一个类中，直接写方法名调用，不同的类中，对象.方法名（）;
*/

类的构造器

/*类的构造器
1、构造器的作用--创建对象的时候，给对象进行初始化
2、构造器的语法格式：
	修饰符 类名(参数列表){
	初始化语句
}
3、构造器根据参数列表的不同，又分为两类：
①隐式无参构造（系统默认提供）
②显式定义一个或者多个构造器（有参、无参）


4、注意：
①一旦定义了显式的构造器，系统就不在提供隐式构造器
②一个类可以创建多个重载的构造器--构造器重载时参数列表一定不能相同
③父类的构造器不可以被子类继承--子类默认继承父类的属性和方法，
但不会继承父类的构造器，而是在子类被实例化时会默认调用父类的空构造器。
子类在创建的时候会调用自己的空构造器，并在调用空构造器会隐式调用super()，
即父类的空构造器。如果父类的构造器被重载，那么子类中的构造器也必须初始化父类的构造器，
否则会报编译错误。当然，只要父类中显示定义了空构造器，子类中就不必初始化父类的构造器
*/
public class Student{
	private String name;
	private int age;
	
	//Student类的无参构造--自己定义了系统就不在提供
	public Student(){
	}
	//Student类的有参构造
	public Student(String name){//参数列表为name
		this.name = name ;
	}
	public Student(String name int age){//参数列表为name和age
		this.name = name;
		this.age = age ;
	}
}

2、java的三大特性

2.1 封装

类的封装

/*
1、为什么要使用封装：防止使用者对类内部定义的属性的直接操作
会导致数据的错误和混乱以及安全性的问题，使用者调用只能通过对象
本身给外部提供的公共访问方法才能操作数据，保证数据的安全性
2、具体的方式：Java中通过将数据声明为私有的（private）
在通过提供公共的（public）getXX()和SetXX()方法实现对类的属性的操作
*/
public class Student{
	private String name = "江小白";//学生的姓名
	private int age = 18;//学生的年龄
	
	//student具有的方法
	public void study(){
		System.out.println("学生在努力的学习");
	}
	
	//构造器
	public Student(){
	
	}
	public Student(String name,int age ){
	this.name = name;
	this.age = age;
	}
	//公共的get/set方法
	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;
	}
}
 calss Test{//测试类
	public static void main(String[] args){
		Student student = new Student();//创建学生对象
		student.getName();//通过对象点get/set方法来获取和修改student的属性的值
		student.setAge(18);
		student.show();//通过对象点方法来调用学生类具有的方法
	}
}

2.2 继承

类的继承

/*
1、为什么需要继承？：在我们设计多个类时，多个类之间会出现一些相同的属性或者方法，
针对于这些属性和方法可以通过去设计一个公共类让着两个类去继承这个公共类
继承关键字：extends，在继承之后，针对于公共类中的所有的public修饰的属性或者方法，
我们在外部实例化创建对象时都可以直接调用
2、此处的两个类称之为子类，单独的这个类称之为父类（基类或者超类）
---简单可记为：“子类 is a 父类”
3、继承的语法规则
class Subclass extends Superclass{}
4、继承的作用
	--继承提高了我们的代码的复用性
	--继承让类与类之间产生了联系，为多态的产生提供了前提
	--子类继承父类，就继承了父类的方法和属性，在子类中可以使用
	父类定义的属性和方法，也可以创建新的数据和方法
	--继承的关键字是extends
	--除了构造函数，父类的属性，方法都可以被子类继承
	--继承后构造函数的变化--子类在构造函数中调用了父类的构造函数，
	子类默认调用父类的无参构造，调用的时候super要放在首行
5、继承的特点：
	--单根性  一个类只能继承一个父类，也叫单继承，java只支持单继承，不允许多重继承
	--传递性  父类-->子类-->孙类……
6、什么情况下类不能被继承
final修饰的类不能再被继承
7、检验a是否为类b的对象，返回值类型是boolean型
对象a instanceof 类b 
8、继承的坏处
增加了代码的耦合

*/
public class TestExtends{
	class person{//人类-----父类
		private String name = "哈利波特";
		private int age = 20;
		
		//人的方法
		public void eat(){
			System.out.println("人都喜欢干饭");
		}
		//无参构造器
		public person(){

		}
		//有参构造器
		public person(String name,int age){
			this.name = name;
			this.age = age;	
		}

		//get/set方法
		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;
		}

	}
	//创建一个学生类继承人类------继承关键字extends
	class Student extends Person{
		private int no;//学号

	public student(){
	
	}
	public student(int age){
		this.age = age;
	}
	public int getNo(){
		return no;	
	}
	public void  setNo(int no){
		this.no = no;
	}	
	}
}
//创建一个测试类来进行测试
public class Test{
	public static void main(Sring[] args){
		Student st = new Student();
		st.getName();
		st.setAge(19);
		st.getNo();
		st.eat()	
	}
}

2.3 多态

多态定义及使用

/*
1、多态的定义：多态是同一个行为有多个不同的表现形式和形态的能力，多态是面向对象中最重要的概念，
在java中有两种体现
---方法的重载和重载和重写
---对象的多态性 可以直接应用在抽象类和接口上
总结：多态的基础是继承+重写，多态的使用前提是父类类型指向子类对象
父类 对象 = new 子类（）；
父类类型指向子类对象
2、多态的使用
---父类类型的对象去调用子类的方法。
---调用父类的方法，但是执行的是子类的方法
3、注意：
---一个对象能调用哪些方法取决于对象定义的类型
---一个对象执行哪个方法取决于new的实际类型
---java引用变量有两个类型：编译时类型和运行时类型，编译时类型由声明该变量时使用的类型决定，
运行时类型有实际赋值给该变量的对象所决定----------编译时和运行时类型不一样，就会出现多态
---里氏替换：父类类型出现的任何地方都可以用子类代替，反之不可以
---对象的多态，在java中，子类的对象可以代替父类的对象使用
	一个变量只能由一种确定的数据类型
	一个引用数据类型变量可能指向多种不同类型的对象
	子类可以看做特殊的父类，所以父类类型的应用可以指向字类的对象：向上转型
---一个引用类型变量如果声明为父类的类型，但是实际引用的是子类对象，
那么该变量及不能再访问子类中添加的属性和方法
属性是在编译时候确定的，编译的时候没有子类的成员变量，因此不能够访问
---方法的调用是在运行的时候确定的，所以调用的是子类的方法--实现动态绑定
*/
public class TestPolymorphic{
	class person{
	private String name;
	private int age;
		
	public void run(){
		System.out.println("每个人都可以跑步");
	}
}

	class Adult extends Person{
		public void run(){//子类重写父类的方法
			System.out.println("成年人跑的快");
		}
	}
	class Children extends Person{
		public void run(){//子类重写父类的方法
			System.out.print("小孩子跑的慢")
	}
	
	} 

}

//创建测试类
public class Test{
	public static void main(String[] args){
		Person p = new Adult();//父类类型指向子类对象
		p.run();//父类类型调用父类的方法，但执行的是子类重写的父类的方法
		Person p1 = new Children();
		p1.run();
		
	}
}

---