培训第8天：面向对象初认识

面向对象

1.创建class文件Demo1

/**
 * 
 * 面向对象：
 * 什么是对象？万物皆对象
 * 真实存在的单个个体
 * 
 * 
 * 类:class 类别/类型（数据类型:引用类型)
 * 
 * 面向的特点:封装，继承，多态(抽象)
 * -new(创建对象)
 * -(凡是new出来的都是对象)
 * 
 * 封装：将类中的属性私有化，然后提供对外
 *       的公共的访问方法（get和set方法）
 * 
 * 人:->人类
 * 属性：眼睛，嘴巴...
 * 变量：
 * String eyes
 * int age
 * Strig sex
 * ...
 * 行为: 吃饭，睡觉...
 * 方法:
 * public static void eat(){
 *   syso("吃软饭");
 *   
 * }
 * 
 * 
 * 写一个 People类
 * 
 *
 */
public class Demo1 {
     public static void main(String[] args) {
/*		String name="张三";//初始值
		System.out.println(name);
		
		//创建了一个人类的模型
		People po=new People();//new了一个People类的对象
		po.name="张三";
		po.age=20;
		po.sex="男";
		po.weight=100;
		po.eat();
		
		
		People po2=new People();
		po2.name="李四";
		po2.age=30;
		po2.sex="女";
		po2.weight=120;
		po2.eat();
		System.out.println(po);
		System.out.println(po2);
		*/
    	People po=new People();//无参
    	po.name="张三";
 		po.age=20;
 		po.sex="男";
 		po.weight=100;
 		
 		People po2=new People("李四",30,"女",120);//有参
 		
 		System.out.println(po);
		System.out.println(po2);
	} 
}

2.创建类People.java用作关联

/**
 * 
 * 用来表示所有的人类
 * 变量:
 * 成员变量和局部变量的区别:
 * 1.定义的位置不一样
 *   成员变量是定义在类里面，方法外面的变量
 *   局部变量是定义在方法里面的变量
 * 2.初始值不一样
 *   -成员变量有默认的初始值(int默认是0，String默认是null)
 *   -局部变量没有默认的初始值
 * 3.在内存中的地址不一样（堆，栈，方法区)
 *  -成员变量是存放在堆中的
 *  -局部变量是存放在栈中的
 * 4.生命周期不一样
 * -成员变量是从对象被创建是开始，对象被回收时结束
 * -局部变量是从方法的调用开始，到方法调用结束时结束
 * 
 * 访问修饰符：
 * public：同包类子类和其他
 *   （同一个包中（package），同一个类中，子类中，以及其他地方都可以访问）
 * protected：同包类子类
 * default(默认:就是不写):
 * private:本类
 * 
 * 
 * 
 */
public class People {
	//成员变量
   String name;//姓名
   int age;//年龄
   String sex;//性别
   double weight;//体重
   /**
    * 构造方法：又叫构造函数
    * 什么是构造方法？
    * -方法名和类名一样的方法
    * -没有返回值，也不能加void
    * 
    * 构造方法的作用？
    * -用来给属性赋值的(对类里面的属性初始化的);
    * 
    * 注意：
    * 1.如果我们没有手动给一个类添加构造方法，系统会默认的提供一个（无参构造：没有参数的构造方法）
    * 2.如果我们手动添加了构造方法，系统就不会再提供默认的无参构造了
    * 
    *
    */
   public People() {
	   System.out.println("people的无参构造");
   }
   
    /**
     * 有参构造
     * 
     * this:指代的是当前对象
     * （谁调用指的就是谁）
     * 
     * 注意：this是可以省略的，但是如果在构造方法中，
     * 局部变量的名字和成员变量的名字一样了，this就不能省略了
     * 
     * 重载和重写的区别：
     * -重载：在同一个类中，方法名相同，参数列表不同的两个方法称之为方法的重载
     * (和访问修饰符，返回值类型，方法体没有关系！！！)
     * 
     */            
   public People(String name1, int age, String sex, double weight) {
	super();
	System.out.println("people的有参构造");
	name = name1;
	this.age = age;
	this.sex = sex;
	this.weight = weight;
}



   /**
    * 重写了Object类中的toString()的方法
    * 因为如果不重写，那么我们引用类型的数据打印的时候，
    * 就会按照Object类中的toString()方法中的格式进行输出
    * 注意：在打印引用类型的时候，会默认的调用toString()方法
    * System.out.println()相当于调用该对象中的toString()方法
    */
   
   /**
    * 创建行为：方法
    */
   public void eat() {
	   System.out.println(this.name+"正在吃饭");
   }
 //重写toString方法
  @Override
  public String toString() {
	//return "People [name=" + name + ", age=" + age + ", sex=" + sex + ", weight=" + weight + "]";
	//这个格式是可以改的
	return "姓名是" + name + ", 年龄" + age + ", 性别" + sex + ", 体重" + weight ;
}
  
}

3.Demo2

package day08;

public class Demo1L1 {
	/**
     * 创建一个动物属性:Animal
     * 动物类有属性:
     * 颜色，品种，年龄
     * 动物类有行为：
     * 爬
     * 
     * 
     * 
     * 
     */
	   public static void main(String[] args) {
		  //垃圾回收器 gc()
		   System.gc();
		   
		Animal an = new Animal();
		an.setPinZ("禽兽");  //set设置值
		String setPinZ=an.getPinZ(); //get获取值
		System.out.println(setPinZ);
	}
}

4.创建文件Animal

public class Animal {
	/**
	 * 将Animal中的所有属性都私有化，并生成get和set方法
	 * 创建Animal的对象，将属性赋值
	 */
    //私有并不代表很安全，只是可以对调用者做一些限制
    private String color ;
    private String pinZ;
    private int age;
	public String getColor() {
		return color;
	}
	public void setColor(String color) {
		this.color = color;
	}
	public String getPinZ() {
		return pinZ;
	}
	public void setPinZ(String pinZ) {
		this.pinZ = pinZ;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		if(age>20) { //对输入年龄进行限制
		   System.out.println("年龄太大了");
		}
	}
	

5.堆，栈，方法区

public class Demo2 {
   /**
    * 堆，栈，方法区
    * 堆：用来存放成员变量和new出来的东西
    * 栈：存放的是地址（引用）和局部变量
    * 方法区：方法，类的结构，静态变量等
    * 引用类型
    * 重点：所有引用类型的默认值是null
    */
	public static void main(String[] args) {
	
		
		//应用类型  数组中的数据是int类型
		int [] arr=new int[] {10,20,30};//arr可以是被称为一个引用
		int [] arr2=arr;
		arr2[0]=40;
		
		
		System.out.println(arr[0]);
		int []arr3=null;//是所有引用类型的默认值是null
		int l=arr3.length;//没有指针
		String str="123";
		String str2=str;
		str2="345";
		System.out.println(str);//123  String有常量池所以有点特殊他并不会更改
	}
}

6.总结

1.面向对象特点： 封装， 继承，多态 抽象

​ 类：类型/类别
​ 对象：万物皆对象

​ 对象：真实存在的单个个体
​

2.类

​ class 类别/类型（数据类型:引用类型)

​ 属性：变量（成员变量和局部变量）
​ 行为：方法（五要素）
​

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

​ -定义的位置不一样
​ -初始值不一样
​ -内存中的地址不一样
​ -生命周期不一样

成员变量和局部变量的区别:
 * 1.定义的位置不一样
 *   成员变量是定义在类里面，方法外面的变量
 *   局部变量是定义在方法里面的变量
 * 2.初始值不一样
 *   -成员变量有默认的初始值(int默认是0，String默认是null)
 *   -局部变量没有默认的初始值
 * 3.在内存中的地址不一样（堆，栈，方法区)
 *  -成员变量是存放在堆中的
 *  -局部变量是存放在栈中的
 * 4.生命周期不一样
 * -成员变量是从对象被创建是开始，对象被回收时结束
 * -局部变量是从方法的调用开始，到方法调用结束时结束

构造方法

      -用来给属性赋值的(对类里面的属性初始化的);
      方法名和类名一样的方法
      没有返回值，也不能加void
 重点
      -如果没有手动添加构造方法，系统会默认添加一个无参构造
      -如果手动添加了，系统就不会提供的无参构造了
      

​

this：指代当前对象（谁调用指的就是谁）

​ -this调用成员变量 (在构造方法中this.变量名)
​ -this调用实例方法（没有加static修饰的方法）
​ -this调用构造方法
​ 例如调用无参构造: this()
​ 注意：在调用构造方法的时候，必须出现在代码的第一行

​ 封装：将类中的属性私有化，然后提供公共的set和get方法
​

访问修饰符

​ public 同包类子类其他
​ protected 同包类子类
​ default 同包类
​ private 本类

堆，栈，方法区

​ 堆：new出来的和成员变量
​ 栈：地址（引用）和局部变量
​ 方法区：类的结构，方法，和静态变量
​

toString():要重写toString()

​ System.out.pringtln():默认的在调用对象中的toString()方法，
​ 如果对象类中没有，则会调用Object类中的
​

方法的重载

​ -在同一类中，方法名相同，参数列表不同的两个方法，和访问修饰符，返回值类型，方法体 没有关系！！！
​

引用类型

所有的引用类型默认值都是null

                                                                            2021-07-07  18:29