Java SE基础5（类、对象、成员变量、局部的区别、构造器、this、重载、数组与对象、二维数组）

面向对象:OOP(Obejct Oriented Programming)

1.类 和对象

一切皆对象,java中基本的操作单位就是对象
1)类:
所有同种的特征和行为,抽象出来成为类
是概念,不真实存在的

		学生类: - 实体类
		学生的特征: 成员变量/属性
			姓名 年龄 性别 学号

		学生行为: 成员方法
			吃饭 睡觉 学习

2)对象:
	符合类的特征并且真实存在的独立个体
	符合类的实例化个体 - new对象

3)类和对象的关系:
	先有(声明/定义)类,才能创建类的对象

2.类的定义

1)分类
	a.有实际意义的类 - 实体类
		可以存在真实个体的类: 车类 人类 鼠标类...
	b.没有实际意义的类 - 普通类
		作用:放主方法
2)定义实体类
	a.成员变量
	  可以不用初始化,有默认初始值
	  引用数据类型:null
	  基本数据类型:0

	b.成员方法

3.使用对象的步骤:

1)必须要有实体类
	class Student{
		String name;
		int age;//成员变量
	}
2)创建对象 - 找到主方法 - 放在普通类中
3)有了对象,对象中包含(成员变量和成员方法)	
	调用成员变量:
		stu.name;
	调用成员方法:
		stu.study();

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

1)位置上的区别
  局部变量:方法中
  成员变量:类中
2)初始化的区别:
	局部变量:使用前必须声明 + 初始化
	成员变量:使用前可以不用初始化,因为有默认初始值
3)个数的区别:
	局部变量:声明个数
	成员变量:有对象决定,有多少个对象,就有多少个成员变量
4)JVM内存图中的区别
	第一次使用[只加载一次]类,把类加载进来
	局部变量:存在方法栈中,方法结束,变量消失
	成员变量:存在堆中

	属于类中的成员变量,通过类调用
	stu.car = new Car();

	直接创建对象 - car属于局部变量
	Car car = new Car();

3.构造方法/构造器

1)作用:初始化成员变量
2)特点:
	a.方法名和类名一致
	b.没有返回值类型
	c.修饰词可有可没有(public)
	d.编译器会默认添加无参构造器
		但是,如果有构造器,则不会继续添加无参构造器.
		建议: 手动添加无参构造器

4.this关键词

this:表示当前对象(动态值)
	那个对象调用,就表示那个对象
1)在构造方法中,this可以调用自己的成员变量
	成员变量和局部变量重名时,需要借助this关键词表示成员变量
		this.name = name;
2)在构造方法中,借助this可以调用自己的成员方法
3)在使用this(空参/有参)时需要注意,只能放在构造方法的第一行
4)调用构造器时,this不能省略
	也不能同时调用,会造成死循环

5.方法重载

1)条件:
	a.类型不一样
		ps:(int a)
		   (String a)
	b.个数不一样
		ps: ()
			(int a)
		    (int a, int b)
	c.顺序不一样
		ps: (int a, double b)
		    (double b, int a)
	d.不允许
		(int a, int b)
	    (int b, int a)
2) 跟返回值无关
3) 必须在同一个类中,相同方法名的几个方法,叫做方法的重载

6.数组结合对象使用 - 引用类型数组

1)赋值方式
(1)静态赋值
ps: Student[] stu = {new Student(),new Student()}
(2)动态赋值
ps: Student[] stu = new Student[3];
2)有可能产生的问题:
java.lang.NullPointerException - 空指针异常
产生原因:
调用了空值的 成员变量 或 成员方法
解决办法:
在调用前,new一个对象
3)引用类型数组的使用步骤
(1)给数组初始化
Student[] stu = new Student[3];//默认值都是null
(2)给数组元素初始化
stu[0] = new Student()
stu[1] = new Student()

作业:俄罗斯方块

分析: S、Z、L、J、I、O、T

一个图形,分为4个方块
以一个方位为类:
	Cell类:
		成员变量
			row col
		成员方法
			左移/右移/下移
			画图形的方法

Debug断点测试:

1.F7:执行这一行代码
2.F8:跳过这一行代码
3.Shift + F8:回到上一行代码
4.Ctrl + F2: 结束程序
5.F9:跳到下一个断点

命名规则:

1.只能出现:英文 + 数字 + _ + $
2.不能以数字开头
3.变量名:可读性好,首字母小写,第二个字母开始首字母大写 - 小驼峰命名法
4.包名: 全小写 - 域名倒写
	www.baidu.com
	com.baidu.www
5.方法名:可读性好,名字长度没有要求
		 小驼峰命名法
6.类名:首字母大写,第二个首字母大写 - 驼峰命名法
	Scanner Math String

eg1：
package oop;
/**

• 小车类 - 实体类
  */
  public class Car {
  String name;
  String color;
  double price;

  void run(String user){
  System.out.println(name + “小车在跑”);
  }

}

package oop;
/**

• 普通类 - 用来放主方法

• 引用数据类型: 数组 String 类/对象

• 基本数据类型: 8种
  */
  public class Demo01ClassDefinition {
  public static void main(String[] args) {
  //局部变量
  int a = 10;
  //创建对象 - 实例化对象 - 引用
  //使用变量
  Student stu = new Student();
  //使用对象 - 调用成员变量
  System.out.println(stu.name);
  stu.age = 21;
  stu.name = “小明”;
  //stu有一辆车
  stu.car = new Car();
  System.out.println(stu.age);
  System.out.println(stu.name);
  //调用方法
  stu.study( “java”);

  Student stu1 = new Student();
  stu1.name = "小明";
  stu1.age = 21;
  
  //创建小车类:
  Car car = new Car();
  car.name = "兰博基尼";
  car.color = "骚粉色";
  car.price = 10000000;
  

  }
  }

package oop;
/**

• 学生类(模板) - 实体类
  */
  public class Student {
  //成员变量
  //可以不用初始化,有默认初始值,
  //引用类型默认值:null 基本数据类型:0
  String name;
  int age;
  String sex;
  Car car;//类中有一个类,属于成员变量

  //默认添加构造方法
  Student(){//无参构造方法
  //作用: 初始化成员变量
  /* name = “黑”;
  age = 40;*/
  //this(“红红”,30,new Car());
  }
  //添加 有参构造方法
  Student(String name, int age, Car car){
  //如果在构造器中调用this(),只能放在,第一行
  this();
  //成员变量和局部变量同名时,就近原则,就近使用
  //使用关键词 this表示,
  this.name = name;
  this.age = age;
  this.car = car;
  //this.study(“java”);
  }

  //成员方法
  void study(String subject){
  //int a = 20;
  System.out.println(“正在学习” + subject);
  }
  }

package oop;
/**

• 普通类 - 放主方法
  */
  public class Demo02Init {
  public static void main(String[] args) {
  //构造方法/构造器
  Student stu1 = new Student();
  System.out.println(stu1.age);
  System.out.println(stu1.name);
  System.out.println(stu1.car);
  stu1.name = “小明”;
  stu1.age = 21;
  stu1.car = new Car();
  System.out.println(stu1.age);
  System.out.println(stu1.name);
  System.out.println(stu1.car);

   Student stu2 = new Student("小黑",21,null);
  
  
   Student stu3 = new Student("小红",22,new Car());
  

  }
  }

eg2：
package tetris;
/**

• 格子类 - 实体类
  */
  public class Cell {
  //成员变量
  int row;
  int col;
  //添加无参构造器
  Cell(){

  }
  //有参构造方法
  Cell(int row,int col){
  this.row = row;
  this.col = col;
  }
  //成员方法
  void moveLeft(){
  col–;
  }
  void moveRight(){
  col++;
  }
  void drop(){
  row++;
  }

  /*
  画格子的方法
  有格子的时候画*,没有的时候画-
  /
  void printCell(){
  int totaRow = 20;//行
  int totaCol = 20;//列
  for (int row = 0; row < totaRow; row++) {
  for (int col = 0; col < totaCol; col++) {
  if(this.row == row && this.col == col){
  System.out.print("");
  }else{
  System.out.print("-");
  }
  }
  System.out.println("-");
  }

  }

}

eg3：
package tetris;

/**

• 放主方法
  */
  public class DemoTest {
  public static void main(String[] args) {
  //创建Cell的对象
  Cell cell = new Cell(4,4);
  cell.printCell();
  }
  }

eg4：
package overload;
/**

• 方法重载
  */
  public class Demo01MethodOverLoad {
  public static void main(String[] args) {
  打(“伞”);
  打(1);
  打(“伞”,1);
  }
  //方法 String 表示伞(没有真实意义)
  public static void 打(double san){
  System.out.println(“下雨打伞”);
  }

  public static void 打(String san,int che){
  System.out.println(“下雨打伞”);
  System.out.println(“又打车”);
  }
  public static void 打(int che,String san){
  System.out.println(“下雨打伞”);
  System.out.println(“又打车”);
  }
  public static void 打(String san,String che){
  System.out.println(“下雨打伞”);
  System.out.println(“又打车”);
  }

  //int 表示 打车
  public static void 打(int san){
  System.out.println(“下雨打车”);
  }

  //有返回值
  public static String 打(String ciba){
  System.out.println(“不停的敲打”);
  return “吃到糯米糍吧”;
  }

  public static String 打(int ciba,String name,double d){
  System.out.println(“不停的敲打”);
  return “又吃到糯米糍吧”;
  }
  public static void 打(int ciba,double d,String name){
  System.out.println(“不停的敲打”);
  }
  }

eg5：
package overload;
/**

• 方法重载
  */
  public class Demo01MethodOverLoad02 {
  public static void main(String[] args) {
  //创建对象
  Demo01MethodOverLoad02 demo02 = new Demo01MethodOverLoad02();
  demo02.打(“伞”);
  demo02.打(1);
  demo02.打(“伞”,1);

  }
  //以下方法变成 成员方法

  //方法 String 表示伞(没有真实意义)
  void 打(double san){
  System.out.println(“下雨打伞”);
  }

  void 打(String san,int che){
  System.out.println(“下雨打伞”);
  System.out.println(“又打车”);
  }
  void 打(int che,String san){
  System.out.println(“下雨打伞”);
  System.out.println(“又打车”);
  }
  void 打(String san,String che){
  System.out.println(“下雨打伞”);
  System.out.println(“又打车”);
  }

  //int 表示 打车
  void 打(int san){
  System.out.println(“下雨打车”);
  }

  //有返回值
  String 打(String ciba){
  System.out.println(“不停的敲打”);
  return “吃到糯米糍吧”;
  }

  String 打(int ciba,String name,double d){
  System.out.println(“不停的敲打”);
  return “又吃到糯米糍吧”;
  }
  void 打(int ciba,double d,String name){
  System.out.println(“不停的敲打”);
  }
  }

eg6：
package array;
/**

• 小车类 - 实体类
  */
  public class Car {
  String name;
  String color;
  double price;

  void run(String user){
  System.out.println(name + “小车在跑”);
  }

}

package array;
/**

• 数组结合对象使用 - 引用数据类型数组
  */
  public class Demo01DefereenceArray {
  public static void main(String[] args) {
  //基本数据类型 - 数组
  int[] arr = {1,2,3,4};
  char[] arr2 = new char[]{‘h’,‘i’};
  int[] arr3 = new int[5];//{0,0,0,0,0}

   //引用数据类型数组
   //Student s = new Student();
   //静态赋值
   Student[] stu = {new Student(),new Student()};
   //动态赋值 - 有3个Student对象
   Student[] stu1 = new Student[3];
   System.out.println(stu1[0]);//null
   System.out.println(stu1[1]);//null
   System.out.println(stu1[2]);//null
  
   //修改第一个Student对象中的name属性为"张三"
   //java.lang.NullPointerException - 空指针异常
   //stu1[0].name = "张三";
   //java.lang.NullPointerException - 调用了空的对象的成员方法
   //stu1[0].study("java");
  
   stu1[0] = new Student();
   stu1[0].name = "张三";//赋值 -> 初始化
   System.out.println(stu1[0].name);
  

  }

}

package array;
/**

• 二维数组
  /
  public class Demo02TwoArray {
  public static void main(String[] args) {
  /
  2.有一个int[]类型的数组 b
  b中有4个元素
  b的第一个元素共有3个元素，其中第3个元素是1
  第二个元素的第一个元素是5
  3.有一个int[]类型的数组 c
  c中每一个元素都有3个元素
  其中第二个元素的每一个值都是4
  c中每一个元素都是4
  */

  /*
  1.有一个int[]类型的数组 a
  这个数组一共有3个元素
  其中第一个元素有4个元素
  第二个元素有3个元素
  第二个元素中的第1个元素是2
  第三个元素有5个元素
  */
  int[][] a = new int[3][];
  a[0] = new int[4];
  a[1] = new int[3];
  a[1][0] = 2;
  a[2] = new int[5];

   /* 工整的二维数组
   3.有一个int[]类型的数组 c
   c中每一个元素都有3个元素
   其中第二个元素的每一个值都是4
   c中每一个元素都是4
    */
   int[][] c = new int[2][3];
   c[0] = new int[3];
   c[1] = new int[3];
   //数组的遍历
   for (int i = 0; i < c.length; i++) {
       c[i] = new int[3];
   }
   System.out.println(c.length);
   System.out.println(c[0].length);
  
   c[1][0] = 4;
   c[1][1] = 4;
   c[1][2] = 4;
   for (int i = 0; i <c[1].length ; i++) {
       c[1][i] = 4;
   }
   //数组的遍历
   for (int i = 0; i < c.length; i++) {
       for (int j = 0; j < c[i].length; j++) {
           c[i][j] = 4;
       }
   }
  

  }
  }

package array;

import oop.Car;

/**

• 学生类(模板) - 实体类
  */
  public class Student {
  //成员变量
  //可以不用初始化,有默认初始值,
  //引用类型默认值:null 基本数据类型:0
  String name;
  int age;
  String sex;
  Car car;//类中有一个类,属于成员变量

  //默认添加构造方法
  Student(){//无参构造方法
  //作用: 初始化成员变量
  /* name = “黑”;
  age = 40;*/
  //this(“红红”,30,new Car());
  }
  //添加 有参构造方法
  Student(String name, int age, Car car){
  //如果在构造器中调用this(),只能放在,第一行
  this();
  //成员变量和局部变量同名时,就近原则,就近使用
  //使用关键词 this表示,
  this.name = name;
  this.age = age;
  this.car = car;
  //this.study(“java”);
  }

  //成员方法
  void study(String subject){
  //int a = 20;
  System.out.println(“正在学习” + subject);
  }
  }