Java--面象对象

 什么是面象对象？

 面向对象是相对面向过程而言,面向对象和面向过程都是一种思想
 面向过程,强调的是功能行为
 面向对象将功能封装进对象，强调具备了功能的对象
 面向对象是基于面向过程的
 
 面向对象的特点：
  是一种符合人们思考习惯的思想，可以将复杂的事情简单化，将程序员从执行者转换成了指挥者
  完成需求时：先要去找具有所需的功能的对象来用，如果该对象不存在，那么创建一个具有所需功能的对象。
  这样简化开发并提高复用
  
 面向对象的特征：
  封装(encapsulation)
  继承(inheritance)
  多态(polymorphism)
 
 类与对象的关系：
  java中描述事物通过类的形式体现，类是具体事物的抽象，概念上的定义
  对象即是该类事物实实在在存在的个体
  
 类的定义：
  所有的事物都有两个方面：有什么（属性）：用来描述对象。
  能够做什么（方法）：告诉外界对象有那些功能
  java的定义也是如此：
   属性：对应类中的成员变量
   行为：对应类中的成员函数
   
  成员变量和局部变量的区别：
   成员变量：
   成员变量定义在类中，在整个类中都可以被访问
   成员变量随着对象的建立而建立，存在于对象所在的堆内存中
   成员变量有默认初始化值
   
   局部变量：
   局部变量只定义在局部范围内，如：函数内，语句内等
   局部变量存在于栈内存中
   作用的范围结束，变量空间会自动释放
   局部变量没有默认初始化值
  
 示例：

		public class Person{
			//定义属性(成员变量)
			String name;
			int age;
			
			Person(String name,int age){
				this.name=name;
				this.age=age;
			}
			
			//定义方法
			public static void show(){
			//定义局部变量
				String sex="man";
				System.out.println("name="+name);
				System.out.println("age="+age);
			}
			public static void main(String[] args){
				Person p=new Person("李道福",24);
			}
		}

封装特性：
   是指隐藏对象的属性和实现细节，仅对外提供 公共访问方式。
  好处：
   将变化隔离，便于使用
   提高重用性，提高安全性
  封装原则：
   将不需要对外提供的内容都隐藏起来。
   把属性都隐藏，提供公共方法对其访问
  private关键字：
   是一个权限修饰符，用于修饰成员(成员变量和成员函数) 被私有化的成员只在本类中有效
   常用之一：
   将成员变量私有化，对外提供对应的set ，get 方法对其进行访问，提高对数据访问的安全性

     访问权限：如图

      
  构造函数：
   特点：
   函数名与类名相同，不用定义返回值类型，不可以写return语句
   作用：给对象进行初始化
  this关键字：
   特点：this代表其所在函数所属对象的引用
   换言之：this代本类对象的引用，当在函数内需要用到调用该函数的对象时，就用this

		public class Person{
			//封装类的属性，不让外部任意访问
			private String name;
			private int age;
			//空参数的构造函数
			Person(){}
			//带有参数的构造函数，给对象初始化
			Person(String name,int age){
				this.name=name;
				this.age=age;
			}
			//提供给外部访问类属性的公共方法
			public void setName(String name){
				this.name=name;
			}
			public void setAge(int age){
				this.age=age;
			}
			public String getName(){
				return this.name;
			}
			public int getAge(){
				return this.age;
			}
			//类自定义方法
			public void print(){
				//this指的是引用对象本身
				System.out.println("name="+this.name);
				System.out.println("age="+age);
			}
			
			public static void main(String[] args){
				//创建对象并初始化
				Person p=new Person("李道福",24);
				p.print();
				//通过调用类提供的公共方法访问类中的私有属性
				p.setName("lidaofu");
				p.setAge(23);
				p.print();
			}
		}							

static：静态关键字，用于修饰成员（成员变量和成员函数）
  被修饰后的成员具备以下特点：
          随着类的加载而加载
         优先于对象存在
         被所有对象所共享
         可以直接被类名调用
  使用注意:
         静态方法只能访问静态成员
         静态方法中不可以写this，super关键字
        主函数是静态的
  

		public class Person{
			String name;
			int age;
			//定义静态成员
			static String country="CN";
			Person(){}
			Person(String name,int age){
				this.name=name;
				this.age=age;
			}
			//非静态方法
			public void print(){
				System.out.println("name="+name);
				System.out.println("age="+age);
				//静态属性属于类并不属于对象，所以可以通过类名形式直接调用静态属性
				System.out.println("country="+Person.country);
			}
			//静态方法
			public static void show(){
				//访问类中的静态属性
				System.out.println("country="+country);
				//System.out.println("name="+name);Error,这句是错误的，无法通过编译，静态方法中无法访问非静态属性
			}
			public static void main(String[] args){
				//静态方法中可以调用静态方法
				Person.show();
				Person p=new Person("李道福",24);
				//静态方法中无法调用非静态方法，只能通过对象调用
				p.print();
			}
		}							

继承的特性：
  多个类中存在相同属性和行为时，将这些内容抽取到 单独一个类中，那么多个类无需再定义这些属性和行为,只要继承单独的那个类即可
  多个类可以称为子类，单独这个类称为父类或者超类，子类可以直接访问父类中的非私有的属性和行为
  通过extends 关键字让类与类之间产生继承关系，class 子类 extends 父类{}
  
  Java只支持单继承，不支持多继承，一个类只能有一个父类，不可以有多个父类
  Java支持多层继承(继承体系)
  
  super：关键字，代表父类的引用
  当子父类出现同名成员时，可以用super进行区分，子类要调用父类构造函数时，可以使用super语句
  
  函数覆盖：子类中出现与父类一模一样的方法时，会出现覆盖操作，也称为重 写或者复写
  特性：
   父类中的私有方法不可以被覆盖
   在子类覆盖方法中，继续使用被覆盖的方法可以通过super.函数名获取
  覆盖注意：
   覆盖时，子类方法权限一定要大于等于父类方法权限
   静态只能覆盖静态
  
  子类的实例化过程：
   子类中所有的构造函数默认都会访问父类中空参数的构造函数
   因为每一个构造函数的第一行都有一条默认的语句 super();
   子类会具备父类中的数据，所以要先明确父类是如何对这些数据初始化的
   当父类中没有空参数的构造函数时，子类的构造函数必须通过this或者super语句指定要访问的构造函数
 

		class Fu{
			String name;
			int age=5;
			Fu(String name,int age){
				this.name=name;
				this.age=age;
			}
			public void speak(){
				System.out.println("Fu在运行");
			}
			void show(){
			
			}
			private void eat(){
			
			}
			}
			class Zi extends Fu{
				int score=65;
				int age=3;
				Zi(String name,int age,int score){
				//super用在构造函数中时必须是子类构造函数的第一句
					super(name,age);
					this.score=score;
				}
				
				//子类覆盖父类，子类的权限必须大于等于父类，否则编译失败
				public void show(){ 
				//当父类与子类中出现同名的成员名时，可以用super来访问父类的成员
					System.out.println(super.age);
					System.out.println(super.score);
				}
				public void speak(){
				//super调用父类中成员函数
					super.speak();
					System.out.println("Zi在运行");
				}
				
				//这不叫覆盖，因为父类中该方法的权限是private，
				//子类根本不知道父类是否有相同的方法，这是两个不同的方法
				public void eat(){
				
				}
			}
			public class Test5{
				public static void main(String[] args){
					Zi z=new Zi("lidoafu",8,24);
					z.show();
					z.speak();
				}
			}

静态代码块，构造代码块，构造函数三者的加载运行顺序

		class Person{
			String name;
			int age;
			
			//静态代码块：随着类的加载而加载，只执行一次，是给类进行初始化，优先于主函数运行
			static {
				System.out.println("这是静态代码块部分");
			}
			
			//构造代码块：给对象进行初始化，对象一建立就运行，优先于构造函数运行
			//是给每个对象进行初始化的，每建立一个对象就运行一次
			{
				System.out.println("这是构造代码块部分");
			}
			
			//空参数的构造函数：当类中自定义构造函数后系统就不会有默认的构造函数
			Person(){
			}
			//建立对象时运行
			Person(String name){
				this.name=name;
			}
			Person(String name,int age){
				//this必须是方法的第一句
				this(name);
				this.age=age;
			}
			public void speak(){
				System.out.println("name="+name+"  age="+age);
			}
		}

		public class Test3{
			 
			static{
				System.out.println("Test静态代码块在运行");
			}
			{
				System.out.println("Test构造代码块在运行");
			}
			public static void main(String[] args){
				Person p=new Person();
				Person p2=new Person("lidaofu",24);
				p2.speak();	
			}
		}

 

final特性：
  final可以修饰类，方法，变量
  final修饰的类不可以被继承
  final修饰的方法不可以被覆盖
  final修饰的变量是一个常量，只能被赋值一次
  内部类只能访问被final修饰的局部变量
    
 抽象类：
  Java中可以定义没有方法体的方法，该方法的具体实现由子类完成，该方法称为抽象方法，包含抽象方法的类就是抽象类
  特性：
   抽象类和抽象方法必须用abstract关键字来修饰
   抽象方法只有方法声明，没有方法体，定义在抽象类中
   格式：修饰符abstract 返回值类型函数名(参数列表)
   抽象类不可以被实例化，也就是不可以用new创建对象
   抽象类通过其子类实例化，而子类需要覆盖掉抽象类中所有的抽象 方法后才可以创建对象，否则该子类也是抽象类
  
  abstract不能与final并列修饰同一个类
  abstract不能与private、static、final或native并列修饰同一个方法。
  abstract类中不能有private的数据成员或成员方法

 

		//定义抽象父类
		abstract class Person{
			String name;
			int age;
			//抽象类可以有构造函数
			Person(){}
			Person(String name,int age){
				this.name=name;
				this.age=age;
			}
			//定义抽象方法，但抽象类中可以不定义抽象方法
			public abstract void print();
			//被final修饰的方法无法被子类所复写，被final修饰的类无法被继承
			public final void show(){
				System.out.println("final修饰的方法不可以被复写");
			}
		}

		class Student extends Person{
			double grade;
			Student(){}
			Student(String name,int age,double grade){
				super(name,age);
				this.grade=grade;
			}
			//复写抽象类中的抽象方法
			public void print(){
				show();
				System.out.println("name="+this.name+" age="+this.age+" grade="+this.grade);
			}
			public static void main(String[] args){
				Student s=new Student("lidaofu",24,90);
				s.print();
			}
		}

接口：interface ，可以理解为全是抽象方法的抽象类
 特性：
       接口中的成员修饰符是固定的
      成员常量：public static final
      成员函数：public abstract
      类与接口之间是实现关系，而且类可以 继承一个类的同时实现多个接口
      接口与接口之间可以有继承关系

 

		//定义接口
		interface Person{
			//成员变量修饰符为public static final
			public static final String country="CN";
			//定义抽象方法，成员函数修饰符为public abstract
			public abstract void work();
			public abstract void eat();
			
		}
		//子类实现接口
		class Student implements Person{
			String name;
			int age;
			Student(String name,int age){
				this.name=name;
				this.age=age;
			}
			//复写接口中的抽象方法
			public void work(){
				System.out.println("study---study");
			}
			public void eat(){
				System.out.println("eat food");
			}
			//自定义子类特有方法
			public void print(){
				System.out.println("name="+this.name+" age="+this.age+" country="+this.country);
			}
			public static void main(String[] args){
				Student s=new Student("李道福",24);
				s.eat();
				s.work();
				s.print();
			}
		}

 

多态：某一类事物的多种存在形态
  体现:父类或者接口的引用指向或者接收自己的子类对象
  作用:多态的存在提高了程序的扩展性和后期可维护性
  前提:需要存在继承或者实现关系,要有覆盖操作
 特点:
  成员函数:
  编译时:要查看引用变量所属的类中是否有所调用的成员
  在运行时:要查看对象所属的类中是否有所调用的成员
  成员变量:只看引用变量所属的类

 

//定义抽象父类
		abstract class Person{
			String name;
			int age;
			Person(){}
			Person(String name,int age){
				this.name=name;
				this.age=age;
			}
			abstract void speak();
			abstract void work();
		}
		//继承抽象类
		class Student extends Person{
			Student(){}
			Student(String name,int age){
				super(name,age);
			}
			//复写抽象类中抽象方法
			public void speak(){
				System.out.println("nmae:"+name+" age:"+age);
			}
			public void work(){
				System.out.println("study study");
			}
			public void study(){
				System.out.println("english english");
			}
		}
		//继承抽象类
		class Worker extends Person{
			Worker(){}
			Worker(String name,int age){
				super(name,age);
			}
			public void speak(){
				System.out.println("name:"+name+" age:"+age);
			}
			public void work(){
				System.out.println("gan huo");
			}
		}
		class Test{
			public static void main(String[] args){
				/*
					多态的体现，show()方法中调用的是person的方法，但是在实际运行时运行的却是子类的方法
				*/
				show(new Student("lidaofu",24));
				show(new Worker("daofu",25));	
			}
			//参数类型是Person
			public static void show(Person p){	
				//实际运行时调用的是子类的方法
				p.speak();
				p.work();
				
				if(p instanceof Student)
				{	
					Student s=(Student)p;
					s.study();
				}	
			}
		}