【Java开发语言 03】第三章 面向对象编程（面向对象与面向过程+类和对象+类成员一：属性+类成员二：方法+对象的创建和使用+封装和隐藏+构造器+关键字this,package,import）

java类及类的成员
面向对象的三大特征
其他关键字

1 面向对象与面向过程

OOP:Object OrientedProgramming
POP:ProcedureOrientedProgramming

何为面向对象
打球：
面向过程编写。专注于打球的动作
面向对象编写。打球的动作是归属于谁？人，所以就会出现一个人的对象，人的对象里包含了一个打球的动作

1.1 java类及类的成员

可以用java语言来描述万事万物，把万事万物抽象成一个个的class类
人有什么属性，高矮胖瘦婚否等……
人的行为动作，吃饭，上班，睡觉

用面向对象的思想去分析
类：司机，列车
方法：
司机{紧急刹车(){} }
列车{ 刹车（）{}}
类：我，门
方法：
我{关(门)}
门{开门（）{} 关门（）{} }

类可以只有属性也可以只有方法

2 java语言的基本元素：类和对象

2.1 类的语法格式

2.2 创建Java自定义类

package com.qxcto;

/**
 * 人
 * @author qx
 * 2022-02-07
 */
public class Person {
    //属性，成员变量，类的成员变量可以先声明不用初始化
    //因为类成员变量有默认值，String类型的默认值是null
    String name;
    int age;//int的默认值0

    //行为，方法（函数）

    /**
     *打印姓名
     */
    public void showName(){
        //方法的名称如果是多个单词，首个单词的首字母小写，其他的单词首字母大写
        System.out.println("姓名："+ name);

    }

    /**
     * 获取年龄
     * @return
     */
    public int getAge(){
        //如果是一个有返回值的方法，
        // 那么方法体（就是方法后大括号里的所有东西）的最后一行一定是返回相应的数据
        //使用的是return关键字，返回的数据类型与方法定义的一致
        return age;
    }
}

package com.qxcto;

/**
 * 2022-02-07
 * @author qx
 */
public class Animal {
    String name;
    int eye;//描述眼睛个数
    int legs;

    /**
     * 输出动物吃的食物
     * @param food
     */
    public void eat(String food){//方法的参数
        System.out.println("此种动物的食物是："+ food);
    }

    /**
     * 移动方式
     * @param moveType 移动方式
     */
    public void move(String moveType){
        System.out.println("此种动物的移动方式是："+ moveType);
    }


}

2.3 对象的创建及使用

package com.qxcto;

public class Test2 {
    public static void main(String[] args){
        //实例化Person类，也就是创建Person对象
        //int i = 0;
        Person person = new Person();
        //声明一个Person类型的变量，变量名person
        //实例化Person类并且给person赋值，赋值的值就是当前的实例
        //new Person()就是实例化Person类
        person.name = "张三";//给person对象的name属性赋值
        person.showName();//对象的方法调用
        int i = person.getAge();//有返回值的方法，，在调用之后就会有一个值，这个值就是方法中return的那部分
        System.out.println(i);
        person.age = 11;//给person对象的age属性赋值
        int a = person.getAge();
        System.out.println(a);
    }
}

对于类的使用就两个地方，操作类的变量，调用类的方法

3 类的成员之一：属性

3.1 public和private区别

public class Person1 {
    public String name = "李四";//public公有的，这样的类变量可以在类的外部使用，也可以在本类的方法使用
    private int age;//private私有的，可以在本类的方法使用，不能在类的外部使用
    //修饰符可以用来修饰变量，可以指明变量是一个共有还是私有
    
    public void showAge(){
        System.out.println(age);
    }

}

3.2 static修饰的变量

方法就是函数
代码块直接在类里写一个大括号
实例变量就是在类实例化成对象后才能使用的
static意思是静态的，无需实例化可直接使用

3.3成员变量和局部变量的区别

局部变量没有默认初始化

4 类的成员之二：方法

有（无）参数有（无）返回值的类型

5 对象的创建和使用

package com.qxcto;

public class Student {
    String name;
    int age;
    String course;
    String interest;

    public void showInformation(){
        System.out.println("姓名："+name);
        System.out.println("年龄："+age);
        System.out.println("参加的课程："+course);
        System.out.println("兴趣："+interest);

    }
}

package com.qxcto;

public class Teacher {
    String name;
    int age;
    String course;
    int teachingAge;

    public void showInformation(){
        System.out.println("姓名："+name);
        System.out.println("年龄："+age);
        System.out.println("教授的课程："+course);
        System.out.println("教龄："+teachingAge);

    }
}

 		Student stu = new Student();
        Teacher tea = new Teacher();
        stu.name = "学生1";
        tea.name = "教师1";
        stu.age = 17;
        tea.age = 35;
        stu.course = "高等数学";
        tea.course = "Java语言编程";
        stu.interest = "滑雪";
        tea.teachingAge = 10;
        stu.showInformation();
        tea.showInformation();

6 再谈方法

6.1 什么是方法

6.2 方法的调用

在测试类中写一个和main函数同等级的方法，然后在main方法中实例化本类然后调用

同一个类中，所有的方法可以直接互相调用，不用new去实例化对象

6.3 对象的产生

String为引用类型
测试查看类中不同类型成员变量的默认值

6.4 匿名对象

package com.qxcto;

public class Person2 {
    public String name;
    public int age;
    public String sex;
    public void study(){
        System.out.println("studying");
    }
    public void showAge(){
        System.out.println("age:"+age);
    }
    public int addAge(int i){
        age += i;
        return age;
    }
}

//主函数内
 		Person2 p = new Person2();
        p.name = "lisa";
        p.age = 11;
        p.sex = "女";
        p.study();
        int a =  p.addAge(2);
        System.out.println(a+"  "+p.age);

---

package com.qxcto;

public class Circle {
    int radius;//半径

    //圆面积
    public double area(){
        return 3.1415*radius*radius;
    }

    //圆周长
    public double perimeter(){
        return 2*3.1415*radius;
    }


}

Circle c1 = new Circle();
        c1.radius = 3;
        System.out.println("圆的面积"+c1.area());
        System.out.println("圆的周长"+c1.perimeter());

注意：同类和不同类的访问机制

static修饰的方法只能访问static修饰的变量，普通变量不可以

6.5 方法的参数

6.5.1 方法的重载

	//多个相同名称的方法如果想在一个类中共存
    //那么这些同名方法一定是参数的个数或者参数的数据类型不一样
    //这样的同名方法就叫做重载
    public int add(int x,int y){
        return x + y;
    }
    public double add(double x, double y){
        return x + y;
    }
    public int add(int x ,int y ,int z){
        return x+y+z;
    }

//2.mOL
package com.qxcto;
public class Test(){
	public static void main(String[] args){
 		Test2 t2 = new Test2();
        t2.mOL(3);
        t2.mOL(4,6);
        t2.mOL("嗯嗯");

    }

    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 s){
        System.out.println(s);
    }
 }

//3.max
//主函数体
		Test2 t2 = new Test2();
        System.out.println(t2.max(5,17));
        System.out.println(t2.max(4.7,14.89));
        System.out.println(t2.max(4,7,34));
    }

    public int max(int x ,int y){
        return x>y?x:y;
    }
    public double max(double x,double y){
        return x>y?x:y;
    }
    public double max(double x,double y ,double z){
        return x>y?(x>z?x:z):(y>z?y:z);
    }

6.5.2 体会可变个数的形参

• 思路1：形参部分定义数组名

• 用数组的方式来传递可变个数的参数
  Person类中定义方法
  
  Test,main中调用，传参只能传数组名或者定义数组，不可传元素串（类似“1214”，“呵呵”，“enen”）
  如果没有参数，就要定义一个空数组或者是null
  

• 思路2：形参部分定义…

• 用Java特有的…的方式来传递可变个数的参数，这种参数在使用时与数组的使用方式相同
  Person类中定义方法
  
  Test，main中调用，可以传数组名或元素串（“14124”,“efdsdaf”,“2ef2w呵呵”）
  如果没有参数可以不填
  

• 如果一个方法有多个的形参，可变的形参（…这种的形参）一定要放在所有的参数最后

6.5.3 方法的参数传递

方法只有被调用才有意义

JVM(Java虚拟机)
栈中存放对象的引用地址，真正的对象在堆中存放

• 基本数据类型，值是保存在栈中。引用对象，值是保存在堆中，栈中存的对象在堆中的地址。
  
  

方法的参数传递之基本数据类型

基本数据类型在参数的传递过程中，就是把实参的值复制值到形参上。
先执行的int a = 0,在栈中开辟了一块内存，地址就是AD8500(假设)，存的值是0
调用swap方法，执行int i部分，开辟一块内存，地址是AD8600,值就是从i那里复制过来的值0，执行swap的方法体里面的代码，i = 6，把i在栈中的值再改成15，最终i在栈中的值为15

 public static void part(int i ){
        i = 15;
        System.out.println("part方法内i="+i);//15
}
public static void main(String[] args){
		int a = 0;
        part(a);
        System.out.println("main方法内a="+i);//0
}

方法的参数传递之引用对象

1.DataSwap ds = new DataSwap(),把new DataSwap()存到了堆内存中，地址BE2500
2.ds引用对象存到栈中，地址是AD9500，值是new DataSwap()对象在堆中的地址BE2500
3.调用swap方法，给ds1引用对象保存到栈中地址是AD9600，存的值是来源于实参(ds),就是ds的栈中存的值，这个值实际上就是之前new DataSwap()在堆内存中的地址
到第3步，实际上，ds,ds1其实都是指向同一个对象，这个对象就是在堆内存中地址是BE2500上保存的new DataSwap对象
ds和ds1是引用对象，存的是对象实际在堆中的地址
堆中是对象实际存储的地方
在这个例子中，最后的结果是ds和ds1操作实际上是同一个对象

总结方法的参数传递

1.如果方法的形参是基本数据类型，那么实参（实际的数据）向形参传递参数时，就是直接传递值，把实参的值复制给形参。
2.如果方法的形参是对象，那么实参（实际的对象），向形参传递参数时，也是把值给形参，这个值是实参在栈内存中的值，也就是引用对象在堆内存中的地址

基本数据类型都是保存在栈内存中，引用对象在栈内存中保存的是引用对象的地址，那么方法的参数传递是传递值（是变量在栈内存的值）

7 面向对象特征之一：封装和隐藏

我们需要对这样不能让调用者随意使用的属性做封装和隐藏

设为私有，提供方法增加逻辑控制让调用者有限制的设置
先把属性设置声明私有的，用private关键字。
通过编写public类型的setXXX()和getXXX()方法来设置属性和获取属性，比如对age和set方法，那么方法名就setAge,getAge

四种访问权限修饰符

一个java文件中可以写多个类，只有一个能写public

• T0 为缺省类，在不同包下找不到
  

• 缺省情况
  
  子类中
  
• protected
  任何地方举例，不同包下，导包后依然找不到
  

public class Person(){
	private age;
	
	public void setAge(int i){
		if(i>=0&&i<=130)
		{
			age = i;
		}else{
			System.out.println("输入的年龄"+i+"不在0-130之间");
		}
	}
	
	public int getAge(){
		return age;
	}
}

public class TestPerson(){
	Person b = new Person();
	b.setAge(140);
	Syetem.out.println("当前设置的年龄为："+b.getAge());
	b.setAge(40);
	Syetem.out.println("当前设置的年龄为："+b.getAge());
}

8 类的成员之三：构造器（构造方法）

• 自己写的是显示构造方法
  
  
• 带参数的构造方法
  
  

public class Person{
	private int age;
	public Person(){
		age = 18;
	}
}

public class Person{
	private int age;
	private String name;
	public Person(int a,String n){
		age = a;
		name = n;
	}
}

package com.day06;

public class Point {
    private int x;
    private int y;
    private int z;

    public Point(int a,int b,int c){
        x = a;
        y = b;
        z = c;

    }

    public void setPoint(int a,int b,int c){
        x = a;
        y = b;
        z = c;
    }
    public void printInfo(){
        System.out.println(x+"，"+y+"，"+z);
    }

}

/**
*main方法中调用
*/
		Point p = new Point(3,4,6);
        p.printInfo();
        p.setPoint(23,56,78);
        p.printInfo();

package com.day06;

public class TriAngle {
    private double base = 6.7;
    private double height = 13.89;

    public double area(){
        return (base*height)/2;
    }
}

public class TestTriAngle{
	public static void main(String[] args){
		TriAngle t1 = new TriAngle();
        System.out.println(t1.area());
	}
}

构造器重载

构造器也叫构造方法，既然是方法就可以重载

	/**
     * 构造器的重载，就是为了方便调用方可以灵活的创建出不同需要的对象
     * 重载的多个构造方法实际上就是相当于提供了多个初始化new对象的模板
     */
    public Person5(){
        age = 1;
        name = "张三";
    }
    public Person5(int a){

    }
    public Person5(String s){

    }

    public Person5(int a,String n){
        age = a;
        name = n;

    }

//main方法
		new Person5();
        new Person5(1);
        new Person5("45765");
        new Person5(5,"34567");

public class Person{e
	private String name;
	private int age;
	String school;
	String major;
	public Person(String n, int a){
		name = n;
		age = a;
	}
	public Person(String n,int a, String s){
		name = n;
		age = a;
		school = s;
	}
	public Person(String n,int a, String s,String m){
		name = n;
		age = a;
		school = s;
		major = m;
	}

}

	//main函数体内
	Person p1 = new Person("裴珠泫",13);
	Person p2 = new Person("裴秀智",18,"高中");
	Person p3 = new Person("孙艺珍",28,"大学","演艺");

9 几个关键字：this、package、import

this★

this不可以在static修饰的方法里用
因为static方法可不作用于对象，而this作为指代对象，用于对对象操作的方法，两者冲突

//Girl.java
package com.qxcto;

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;

public class Girl {
    public Girl(){
        System.out.println("无参构造");
    }
    public Girl(String n){
        this.name = n;
        System.out.println("名字为："+this.name);
    }
    String name;
    public void setName(String i){
        this.name = i;
    }
    public String getName(){
      return this.name;
    }
    public void marry(Boy boy){
        System.out.println(this.name+"丈夫是："+boy.name);
    }

}

//Boy.java
package com.qxcto;

public class Boy {
    public Boy(String n ,int a){
        this.name = n;
        this.age = a;
        System.out.println("姓名为："+this.name+"，年龄为"+this.age);
    }
    public Boy(String n){
        this.name = n;
        System.out.println("姓名为:"+this.name);
    }

    public String name;
    public int age;

    public void setName(String i){
        this.name = i;
    }
    public String getName(){
        return this.name;
    }

    public void setAge(int i){
        this.age = i;
    }
    public int getAge(){
        return this.age;
    }
    public void marry(Girl girl){
        System.out.println(this.name+"妻子是："+girl.name);
    }
    public void shout(){
        System.out.println(this.name+"shout");

    }

}

//main
		Girl g1 = new Girl("秀智");
        Girl g2 = new Girl();

        Boy b1 = new Boy("玄彬",40);
        Boy b2 = new Boy("哈尔");

        b2.marry(g1);
        g1.marry(b1);
        b2.shout();

JavaBean

写好私有属性后快速生成get,set方法

选中想要生成方法的属性，ctrl可以多选

自动生成成功

package day06;

/**
 * 一个javaBean
 * 私有的属性
 * 属性对应的get和set方法
 */
public class Person {
    private String name;//姓名
    private int sex;//1男，0女
    private int age;//年龄

    public void setName(String name){
        this.name = name;
    }

    public String getName(){

        return this.name;
    }

    public void setSex(int sex){
        this.sex = sex;
    }

    public int getSex(){
        return this.sex;
    }

    public void setAge(int age){
        this.age = age;
    }
    public int getAge(){
        return this.age;
    }

}

package

问题，在使用电脑时，如果不建文件夹，所有的文件都直接放在D盘下。
乱，根本分不清哪些文件是属于哪些软件
其次，同名文件，qq的软件里面有一个名叫data的文件，微信中也有一个data文件。同名文件在同一个文件夹下无法处理。

在java中包的概念就是和文件夹的概念类似，同样，包的存在也是为了解决以上问题（文件太乱不好管理和文件同名）
选择包下的.java加ctrl键可以拖拽到其他包，包下再建包，命名为上层包名.自己包名
java中的包package等同于文件夹的概念，包和文件夹一样可以有多级，也就是包下可以有包和文件，多级的包使用.分隔，例如com包下的cn包下的test包，写法就是com.cn.test
同一个包底下，文件不重名即可
使用同一个包下的类，可以不import

import

这个是使用不同的包底下的java类的一个方式
java.lang包参考
下图转载

• 使用别的包下的类
  1.自己手动写import导要用的类
  
  2.直接使用后Alt+Enter自动添加导包的import句
  
  3.不用import
  
  4.导整个包,包括其中所有的java类
  

JDK中主要的包的介绍