java day05之面向对象

红太狼 2022-04-14 04:55 227阅读 0赞

## 学习面向对象的三条主线 ##

1.java类及类的成员

2.面向对象的三大特征

3.其他关键字

## 面向对象（OOP）与面向过程 ##

（1）二者都是一种思想，面向对象是相对于面向过程而言的。面向过程，强调的是功能行为。面向对象，将功能封装进对象，强调具备了功能的对象

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

## 面向对象的三大特征 ##

1）封装（Encapsulation）

2）继承（Inheritance）

3) 多态（Polymorphism）

## 理解和区分面向对象和面向过程 ##

package com.huake.java;
    /*
     理解一：人开门
     面向过程:人  打开 门
     面向对象：
     人{
          打开(门){  门.开开()  }
    
     
      门{
         开开(){ } }
     
     理解二：人 把大象装进冰箱
     面向过程：1）打开冰箱  2）把大象放进去  3）关闭冰箱门
     面向对象：
     人{
                打开(冰箱){ 冰箱.开开()}
               操作(大象){ 大象.进入(冰箱) }
               关闭(冰箱){ 冰箱.关闭() }
     }
     
     大象{
                   进入(冰箱){ }
     }
     
     冰箱{
          打开(){}
          关闭(){}
     }
     */
    public class TestOOP {
    
    }

## 面向对象的思想概述 ##

1）完成需求时：

①先去找具有所需功能的对象来用。

②如果该对象不存在，那么创建一个具有所需功能的对象

③这样简化开发并提高复用

2）类（class）和对象（object）是面向对象的核心概念

①类是对一类事物的描述，是抽象的。概念上的定义

②对象是实际存在的该类事物的每个个体，因而也称实例（instance）

3）万事万物皆对象

属性：对应类中的成员变量

行为：对应类中的成员方法，也就是函数

## 设计类与创建类 ##

package com.huake.java;
    /*
     * 面向对象思想的落地法则
     * 1.设计类，并设计类的成员（成员变量和成员方法）
     * 2.通过类，来创建类的对象（也叫作类的实例化）
     * 3.通过“对象.属性”或“对象.方法”来调用，完成相应的功能
     * 
     * 创建的多个对象，各自拥有一套类的属性，
     * 当对其中一个对象的属性进行修改时 ，
     * 不会影响到其他对象的属性值
     * */
    public class Zoo {
        public static void main(String[] args) {
    	//1.类的实例化:如下的a1就是一个实实在在的对象
    	Animal a1=new Animal();
    	a1.name="huahua";
    	a1.age=2;
    	System.out.println("name:"+ a1.name+"   age:"+a1.age);
    	//通过对象调用方法
    	a1.eat();
    	a1.sleep();
    	//再创建一个类的对象
    	Animal a2=new Animal();
    	System.out.println("name:"+ a2.name+"   age:"+a2.age);//null 0
    	}
    }
    class Animal{
    	//1.属性
    	String name;
    	int age;
    	//2.方法
    	public void eat(){
    		System.out.println("eat");
    	}
    	public void sleep(){
    		System.out.println("sleep");
    	}
    	public String getName(){
    		return name;
    	}
    	public void setName(String n){
    		name=n;
    	}
    }

## 设计类的成员变量及方法 ##

package com.huake.java;
    /*
     * 1.面向对象的编程关注于类的设计
     * 2.设计类实际上就是设计类的成员
     * 3.基本的类的成员：属性（成员变量或Field） & 方法（Method）
     */
    import java.util.Scanner;
    public class TestPerson {
       public static void main(String[] args) {
    	   Person p1=new Person();
    	   p1.info();
    	   p1.name="dabai";
    	   p1.age=21;
    	   p1.sex=true; //true代表男
    	   p1.info();
    	   p1.setName("xiaohei");//相当于p1.name="xiaohei"
    	   p1.info();
    	   
    	   Person p2=p1;
    	   System.out.println("p1:"+p1);
    	   System.out.println("p2:"+p2);
    	   p2.info();
    	   
    	   p2=new Person();
    	   System.out.println("p2:"+p2);
    	   p2.info();
    	   
    	   //实例化Scanner类的对象，通过此对象.nextXX（）调用，完成相应的功能
    	   Scanner s=new Scanner(System.in);
    	   int i=s.nextInt();
       }
    }
    //类 是抽象的
    class Person{
    	//1.属性：Field
    	String name;
    	int age;
    	boolean sex;
    	
    	//2.方法
        public void eat(){
        	System.out.println("人吃饭");
        }
        public void sleep(){
        	System.out.println("人睡觉");
        }
        public String getName(){
        	return name;
        }
        //给属性name赋值
        public void setName(String n){
        	name=n;
        }
        
        public void info(){
        	eat();
        	sleep();
        	System.out.println("name:" + name + "  age:" + age + "  sex:" + sex);
        }
    }

## 类的访问机制 ##

1）在一个类中的访问机制：类中的方法可以直接访问类中的成员变量。（例外：static方法访问非static，编译不通过）

2）在不同类中的访问机制：先创建要访问类的对象，再用对象访问类中定义的成员。

## 案例一：创建一个Person类 ##

package com.huake.exer;
    /*
     * 要求：（1）创建Person类的对象，设置该对象的name、age和sex属性，调用study方法，
     * 输出字符串“studying”，调用showAge()方法显示age值，调用addAge()方法给对象的age属性
     * 值增加2岁。
     *    （2）创建第二个对象，执行上述操作，体会同一个类的不同对象之间的联系
     *    */
     //测试类
    public class TestPerson {
    	public static void main(String[] args) {
    		Person p=new Person();
    		p.study();
    		p.showAge();
    		p.addAge(2);
    		p.showAge();
    		Person p1=new Person();
    		p1.showAge();
    	}
    
    }
    class Person{
    	//1.属性
    	String name;
    	int age;
    	int sex;
    	//2.方法
    	public void study(){
    		System.out.println("studying");
    	}
    	public void showAge(){
    		System.out.println(age); //打印调用showAge()方法的对象的age属性
    	}
    	//给调用此方法的对象的age属性增加i岁，并返回新的age
    	public int addAge(int i){
    		age+=i;
    		return age;
    	}
    	
    }

## 案例二：利用面向对象 计算圆的面积 ##

package com.huake.exer;
    //利用面向对象的编程方法，设计类Circle计算圆的面积
    public class TestCircle {
    
    	public static void main(String[] args) {
    		Circle c=new Circle();
    		//c.findArea(2.0);
    		c.r=2.0;
    		double area=c.findArea();
    		System.out.println(area);
    		c.setR(4.5);
    		System.out.println(c.findArea());
    
    	}
    
    }
    class Circle{
    	double r;   //半径
    	//提供方法用于获取圆的面积
    //	public void findArea(double r){
    //		//此处的r为调用findArea()方法的对象的属性r
    //		System.out.println(3.14*r*r);
    //	}
    	public double findArea(){
    		return r * r * 3.14;
    	}
    	public double getR(){
    		return r;
    	}
    	public void setR(double ra){
    		r=ra;
    		
    	}
    }

## 案例三：使用面向对象编程数组最大值最小值遍历输出反转 ##

package com.huake.java;
    
    public class ArrayUtil {
       //求数组的最大值
    	public int getMax(int [] arr){
    		int max=arr[0];
    		for(int i=0;i<arr.length;i++){
    			if(max<arr[i]){
    				max=arr[i];
    			}
    		}
    		return max;
    	}
    	//求数组的最小值
    	public int getMin(int [] arr){
    		int min=arr[0];
    		for(int i=0;i<arr.length;i++){
    			if(min>arr[i]){
    				min=arr[i];
    			}
    		}
    		return min;
    	}
    	//遍历数组元素
    	public void printArray(int [] arr){
    		System.out.print("[");
    		for(int i=0;i<arr.length;i++){
    			System.out.print(arr[i]+"\t");
    		}
    		System.out.print("]");
    	}
    	//求数组的平均数
    	public int avg(int []arr){
    		int sum=0;
    		for(int i=0;i<arr.length;i++){
    			sum+=arr[i];
    		}
    		return sum/arr.length;
    	}
    	//求数组的总和
    	public int getSum(int [] arr){
    		int sum=0;
    		for(int i=0;i<arr.length;i++){
    			sum+=arr[i];
    		}
    		return sum;
    	}
    	//数组的反转
    	public int [] reverse(int [] arr){
    		for(int i=0;i<arr.length/2;i++){
    			int temp=arr[i];
    			arr[i]=arr[arr.length-1-i];
    			arr[arr.length-1-i]=temp;
    		}
    		return arr;
    	}
    	//数组的复制
    	public int [] copy(int [] arr){
    		int [] arr1=new int [arr.length];
    		for(int i=0;i<arr.length;i++){
    			arr1[i]=arr[i];
    		}
    		return arr1;
    	}
    	//对 数组进行排序
    	public void sort(int [] arr){
    		for(int i=0;i<arr.length-1;i++){
    			for(int j=0;j<arr.length-i-1;j++){
    				if(arr[j]>arr[j+1]){
    					int temp=arr[j];
    					arr[j]=arr[j+1];
    					arr[j+1]=temp;
    				}
    			}
    		}
    	}
    }
    
    
    
    
    
    
    
    
    
    
    
    
    
    package com.huake.java;
    
    public class TestArray {
       public static void main(String[] args) {
    	  int [] arr=new int []{12,4,76,0,-98,56,37,100};
    	  ArrayUtil au=new ArrayUtil();
    	  int max=au.getMax(arr);
    	  System.out.println("最大值为："+max);
    	  
    	  int avg=au.avg(arr);
    	  System.out.println("平均值为："+avg);
    	  
    	  System.out.println("数组本身如下：");
    	  au.printArray(arr);
    	  
    	  System.out.println();
    	  System.out.println("反转数组如下：");
    	  au.reverse(arr);
    	  au.printArray(arr);
    	  
    	  System.out.println();
    	  System.out.println("对数组进行排序：");
    	  au.sort(arr);
    	  au.printArray(arr);
       }
    }

## 重载的概念： ##

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

## 重载的特点： ##

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

## 重载实例 ##

package com.huake.java;
    /*
     * 方法的重载（overload）
     * 要求：1.在同一个类中  2.方法名必须相同（getSum） 
     *     3.方法的参数列表不同（参数的个数不同，参数个数相同但是类型不同）
     * 补充:方法的重载与方法的返回值类型没有关系*/
    public class TestOverload {
    
    }
    class Overload{
    	//定义两个int型遍历的和
    	public int getSum(int i,int j){
    		return i+j;
    	}
    	//定义三个遍历的和
    	public int getSum(int i,int j,int k){
    		return i+j+k;
    	}
    	//不能与其他几个方法构成重载
    //	public int getSum1(int i,int j,int k){
    //		return i+j+k;
    //	}
    //	public void getSum(int i,int j,int k){
    //		System.out.println(i+j+k);
    //	}
    	//定义两个double类型的数据的和
    	public double getSum(double d1,double d2){
    		return d1+d2;
    	}
    	//定义三个double类型的数据的和
    	public void getSum(double d1,double d2,double d3){
    		System.out.println(d1+d2+d3);
    	}
    	
    	
    	public void method1(int i,String str){
    		
    	}
    	public void method1(String str1,int j){
    		
    	}
    }

## 案例： ##

package com.huake.exer;
    /*题目一
     * 编写程序，定义三个重载方法并调用，方法名为mOL
     * 三个方法分别接收一个int参数，两个int参数，一个字符串参数，分别执行平方运算并输出结果
     * 相乘并输出结果，输出字符串信息
     * 在主类的main()方法中分别用参数区别调用三个方法
     * 题目二：
     * 定义三个重载方法max（），第一个方法求两个int值中的最大值
     * 第二个方法求两个double中的最大值
     * 第三个方法求三个double中的最大值，并分别调用三个方法*/
    
    public class TestOverload {
    	public static void main(String[] args) {
    		TestOverload t=new TestOverload();
    		t.mOL(12);
    		t.mOL("www.huake.com");
    		System.out.println(t.max(12,13));
    		System.out.println(t.max(12.1,14.3));
    	}
    	public double max(double d1,double d2,double d3){
    		return (max(d1,d2)>d3)?max(d1,d2):d3;
    	}
    	public double max(double d1,double d2){
    		return (d1>d2)?d1:d2;
    	}
    	public int max(int i,int j){
    		return (i>j)?i:j;
    	}
    	
    	//以上三个方法构成重载
    	
    	//以下三个方法构成重载
    	public void mOL(int i){
    		System.out.println(i*i);
    	}
        public void mOL(int i,int j){
    		System.out.println(i*j);
    	}
        public void mOL(String str){
    		System.out.println(str);
    	}
    
    
    }