数组面向对象的知识和技术总结

最新推荐文章于 2023-04-04 21:51:24 发布

Tunaep

最新推荐文章于 2023-04-04 21:51:24 发布

阅读量160

点赞数

本文链接：https://blog.csdn.net/Tunaep/article/details/79905592

版权

数组

* 数组:可以存储多个元素并且多个元素是同一种类型的容器
*
* 数组的定义:
*   数据类型[] 数组名;
*   数据类型数组名[];
*
* 举例:
*   int[] a;  定义了一个int类型的数组变量a
*   int a[] ;       定义了一个int类型变量a数组
*
* 这两种方式的定义:虽然写法不一样,并且读法不一样,但是表达的效果一样,都是在定义一个数组,推荐使用第一种方式;
*
*
* 数组的初始化:
*    1)动态初始化: 给数组指定长度,数组中的元素值由系统默认给定
*    2)静态初始化: 给定数组中元素的值,数组的长度由系统给定;
*
*
* 动态初始化:
*     数据类型[] 数组名 = new 数据类型[数组长度] ;
*
* 举例:
*   int[] arr = new int[3] ;

* 数组的静态初始化:
*    指定数组的元素,长度由系统给定
*
* 定义个数:
* 原始格式:
*   数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3....} ;
* 简写方式:
*   数据类型[] 数组名称= {元素1,元素2,元素3..} ;
*

* 数组中经常会出现的异常:
*
*   ArrayIndexOutOfBoundsException:数组角标越界异常
*     出现的原因:访问了数组中不存在的索引值;
*     解决方案:观察数组中到底有索引值到多少; 数组长度-1
*   NullPointerException:空指针异常 (在实际开发中该异常是最多的)
*     出现的原因:对象为null,而开发者还要去使用对象,就会出现问题
*     解决方案:给某个对象进行非空判断,防止程序程序空指针异常
*
* 对于异常:
*   把从头到尾,将遇见到的异常建立文档,
*     出现该异常的原因
*     如何解决异常
*
*
* OOM异常:OutOfMemory:内存溢出   Android 解决加载大量图片的问题:图片加载器:ImageLoader等等
* 举例:
*   int[] arr = new int[]{1,2,3} ;
*   int[] arr = {1,2,3} ;
*
* 这种方式错误:动静结合定义数组要么动态初始化,指定长度,要么静态初始化指定数组元素!
*   int[] arr2 = new int[3]{1,2,3} ;

面向对象

面向过程:
  假设有一个需求:求数组中的最大值;
  定义一个数组,静态初始化---->定义一个参照物---->遍历....
  给一个需求,对需求分析,然后一步一步进行操作,最终得到某一个结果,整个过程都是自己在完成....

面向对象的思想概述:
  思想的特征:
   1)面向对象更符合我们的生活中的行为思想习惯
   2)面向对象将我们从执行者变成了指挥者,指挥对象做事情
   3)面向对象简单性体现在这里:让我们事情从复杂性--->简单化

  举例:

         洗衣服:
                    面向过程:脱下脏衣服--->放到一个盆里面--->加水,洗衣液---->泡一泡--->搓一搓---->拧一拧----->晾一晾
                    面向对象:脱下脏衣服--->放到一个全自动洗衣机中--->一键---->晾一晾

举例:
把大象装进冰箱

  1)装大象的方法in()
  2)开冰箱门:open()
  3)关闭冰箱门:close()

			class Test{
				
				main(..){
					//分别调用三个方法
					open();
					in();
					close();
				}
				
				
				//开冰箱门
				public static void open(){
					System.out.println("开冰箱门...") ;
				}
				//装大象
				public static void in(){
					System.out.println("把大象塞进冰箱") ;
				}
				
				//关闭冰箱门
				public static void close(){
					System.out.println("开冰箱门...") ;
				}
			}

面向对象:

把大象装进冰箱 : 名词提取法: 大象类,冰箱类,测试类

			class 大象类{
				public static void in(){
					System.out.println("把大象塞进冰箱") ;
				}
			}
			
			class 冰箱类{
				public static void open(){
					System.out.println("开冰箱门...") ;
				}
				
				public  static  void close(){
					System.out.println("开冰箱门...") ;
				}
			}
		
			class Test{
				main(){
				
				
					类名.方法名() ;
					大象类.in() ;
					冰箱类.open();
					并迅雷.close() ;
			
				}
			}

面向对象的三大特征:
                               封装
                               继承
                               多态

面向对象语言中现实世界的事物在代码中如何体现的

学生
          属性:姓名年龄性别 ...学号
          行为:学习,打游戏....


学生现实世界的事物------>代码    学生类:Student
属性:属性:姓名年龄性别 ...学号              成员变量:name,age,sex...
行为:学习,打游戏.... 成员方法:study(),playGame();

总结:
               面向对象
                                 :将事物看成XX类,将事物对应的属性--->看成这个类的成员变量
                                  将事物对应的行为----->看成这个类的成员方法

描述一个学生事物,
                              属性:姓名,年龄,性别,学号
行为:学习


在Java中,创建对象:new对象
类名对象名 = new 类名();

//这是一个学生类
public class Student {
	
	//成员变量
	String name ;
	int age ;
	String gender ;
	int Id ;
	
	
	//成员方法:学习的方法
	//先去掉static
	public void study() {
		System.out.println("学生在学习Java.....") ;
	}
}

//学生类的测试类
public class StudentTest {

	public static void main(String[] args) {
		
		//创建一个学生对象
//	格式:	类名 对象名 = new 类名() ;	
		Student s = new Student() ;
		//System.out.println(s);//org.westos.oop.Student@70dea4e  包名.类名@(地址值标记)16进制数据
		System.out.println("学生的姓名是:"+s.name+",年龄是:"+s.age+",性别是:"+s.gender+",学号是:"+s.Id);
		
		//给学生对象进行赋值
		s.name = "高圆圆" ;
		s.age = 27 ;
		s.gender = "女" ;
		s.Id = 007 ;
		System.out.println("学生的姓名是:"+s.name+",年龄是:"+s.age+",性别是:"+s.gender+",学号是:"+s.Id);
		
		//调用Student类中的成员方法
		//对象名.成员方法名() ;
		s.study(); 
		
		
	}
}

匿名对象

* 匿名对象:
* 就是创建对象的时候,没有名字的对象

class Student{
	
	String name ;
	int age ;
	
	public void show() {
		System.out.println(name+"---"+age);
	}
}

//学生类的测试类
public class StudentDemo {
	
	public static void main(String[] args) {
		
		//创建一个学生类对象
		Student s = new Student() ;//该对象名s
		s.name = "高圆圆" ;
		s.age = 28 ;
		s.show(); 
		
		System.out.println("------------------");
		//匿名对象(开发中经常使用),没有名字的对象
		System.out.println(new Student());//org.westos.noname.Student@70dea4e
		new Student().name = "赵又廷" ;
		
		/**
		 * 匿名对象在实际开发中,只用使用一次,不要使用多次  (可能会造成一个内存溢出的现象);
		 */
		new Student() ; //一直给堆内存开辟空间 
		new Student () ;
		
	}
}

形式参数

* 形式参数的问题:
* 如果是基本数据类型,形式参的改变对实际参数没有影响
* 研究引用类型:形式参数的改变会直接影响实际参数

class Demo{
	
	//求和的成员方法
	public int sum(int a,int b) { //形式参数是基本类型  :
		return a+b ;
	}
}

//一个学生类
class Student{
	public void show() {
		System.out.println("好好学习,天天向上....");
	}
}

class StudentDemo{
	//method方法中形式参数是一个引用类型:需要的是学生类对象  Student s = new Student () ;
	public void method(Student s) {//形式参数现在引用类型  
		s.show(); 
	}
}

//测试类
public class ArgsTest {
		
	public static void main(String[] args) {
		//创建Demo类对象
		Demo d = new Demo() ;
		System.out.println(d.sum(10, 20)) ;
		System.out.println("-------------------------");
		
		//需求:调用StudentDemo中的method方法:如何调用
		//1)创建StudentDemo类对象
		StudentDemo sd = new StudentDemo() ;
		//2)形式参数是Student类型,所以创建Student类的对象
		Student s = new Student() ;
		sd.method(s);
		
	}
}

private关键字

* private的用法:
*    1)被private修饰的只能在本类访问
*    2)可以通过公共的访问public 去间接访问
*
*
*
* 当前成员变量和局部变量名称一致的情况,遵循就近原则

class Demo{
	private int num = 100 ;
	
	//成员方法 :公共访问方法
	public void method()	{
		int num = 200 ; //局部变量
		System.err.println(num);
	}
}
//测试类
public class PrivateDemo {
	
	public static void main(String[] args) {
		//创建一个Demo类的对象
		Demo d = new Demo() ;
//		System.out.println(d.num);//外界不能访问
		d.method(); 
		
	}
}

* 创建一个学生类,
*    成员变量:姓名和年龄
*    测试这个学生类
*
* 分析:
*   刚才通过下面代码给学生的年龄赋值了一个不合理的数据,而这种不合理的数据依然可以被输出出来,有问题!
* 解决方案?
*   在Student类中提供一个针对年龄的判断的一个方法
*
*   虽然提供了这一个方法,但是成员变量在测试类中永远被访问到,针对这种情况:Java提供了关键字:private:私有的
*
* private:体现的也是一种封装思想
* 封装:
*   标准类的写法,将成员变量全部私有化,被private修饰的成员变量只能在本类中访问,可以通过公共的访问方法去访问成员变量

//学生类 class Student{ //实体类 String name ; // int age ; //用private 修饰成员变量 private int age ; public void show() { System.out.println(name+"---,"+age); } //针对年龄进行一个判断 public void ageTest(int age) { if(age <0 || age >120) { System.out.println("该年龄是一个不合理数据...."); } } }

//测试类 public class StudentDemo {

public static void main(String[] args) { //创建一个学生类对象 Student s = new Student() ; s.name = "高圆圆" ; s.age = 27 ;

s.show(); System.out.println("---------------"); s.name = "赵又廷" ; s.age = -30 ; s.show(); s.ageTest(s.age); s.show(); } }

* 写一个手机类

class Phone{
	//私有修饰
	private String brand ;
	private int price ;
	private String color ;
	
	//成员方法
	//提供公共的访问方法
	public void setBrand(String brand) {
		brand = brand ;
	}
	
	//获取手机品牌
	public String getBrand() {
		return brand ;
	}
	
	public void setPrice(int p) {
		price = p ;
	}
	public int getPrice() {
		return price ;
	}
	
	public void setColor(String c) {
		color = c ;
	}
	public String getColor() {
		return color ;
	}
	
}

//测试类
public class PhoneDemo {
	
	public static void main(String[] args) {
		
		//创建手机类对象
		Phone p = new Phone() ;

		p.setBrand("小米");
		p.setPrice(1699);
		p.setColor("黑色");
		System.out.println(p.getBrand()+"---"+p.getPrice()+"----"+p.getColor());
		
	}
}

static关键字

* 定义一个人类
* 成员变量:姓名年龄国籍
* 创建了三个Person对象,每一个对象的国籍都是中国,值是重复的,这样的话在堆内存中比较浪费内存空间,不好
*
* 针对这种情况,多个对象对同一个变量进行共享,这个时候Java提供了一个关键字---static: 静态的(共享的)
* 在方法区中:开辟一个静态区域: 都是静态标记

//定义一个人类
class Person{
	
	String name ; //姓名
	int age  ; //年龄
//	String country ; //国籍
	
	//改进:
	static String country ;
	
	public Person() {}
	
	//三个参数的构造方法
	public Person(String name,int age,String country) {
		this.name = name ;
		this.age = age ;
		this.country = country ;
	}
	
	//提供两个参数的构造方法
	public Person(String name,int age) {
		this.name = name ;
		this.age = age ;
	}
	
	//show方法的作用:来输出成员变量的值
	public void show() {
		System.out.println("姓名是"+name+",年龄是:"+age+",国籍是:"+country);
	}
}

//测试类
public class StaticDemo {

	public static void main(String[] args) {
		
		//创建人类的对象
		Person p1 = new Person("西施", 27, "中国") ;
		p1.show(); 
		
//		Person p2 = new Person("杨贵妃",28,"中国") ;
		Person p2 = new Person("杨贵妃", 28) ;
		p2.show(); 
		
//		Person p3 = new Person("高圆圆", 27, "中国") ;
		Person p3 = new Person("高圆圆", 27) ;
		p3.show(); 
		
		p3.country = "美国" ;
		p3.show();
		
		p1.show(); 
		p2.show(); 
		
	}
}

* 关于static关键字:
*   1)静态随着类的加载而加载
*   2)static优先于对象存在
*    回想:main public static void main(..){...}
*
*   3)static共享数据,可以被多个对象进行共享
*    举例: 饮水机(staticd的:共享的)
*      水杯(不能共享的...)
*   4)如果数据被静态修饰的,它可以被类名直接调用
*      被静态修饰的方法: 类名.方法名()
*      被静态修饰的变量: 类名.变量名;

* static用法:
*
*   一个类中可有静态变量,也可以有非静态
*     可以有静态成员方法,也可以非静态的成员方法
*      静态的方法只能访问静态变量,或者是静态的方法
*      非静态的方法,既可以访问静态变量也可以非静态的变量...
*
* 简单记:静态只能访问静态

this关键字

* 定义变量,方法,类,接口,做到见名知意
* 在手机类中的公共的访问方法中,对应局部变量名称应该做到见名知意
*
* 虽然做到见名知意了,但是局部变量将成员变量可以隐藏掉,Java提供一个关键字:this
*
* this:代表是当前类对象,或者是(当前类对象的引用),解决局部隐藏了成员变量

//手机类
class Phone{
	
	//私有修饰
	private String brand ;
	private int price ;
	private String color ;
	
	//成员方法
	//提供公共的访问方法
	public void setBrand(String brand) {
//		brand = brand ;
		this.brand = brand;
	}
	
	//获取手机品牌
	public String getBrand() {
		return brand ;
	}
	
	public void setPrice(int price) {
//		price = price ;
		this.price = price ;
	}
	public int getPrice() {
		return price ;
	}
	
	public void setColor(String color) {
		//color = color ;
		this.color = color ;
	}
	public String getColor() {
		return color ;
	}
	
}

//测试类
public class Test {
	
	public static void main(String[] args) {
		
		//创建手机类对象
		Phone p = new Phone() ;
		p.setBrand("华为");
		p.setPrice(1999); 
		p.setColor("黑白");
		
		System.out.println(p.getBrand()+"---"+p.getPrice()+"----"+p.getColor());
		System.out.println("-----------------------");
		
		Student s = new Student() ;
		s.setName("高圆圆");
		s.setAge(28); 
		s.setsId("xx002");
		s.setGender('女');
		s.setTitle("学习委员");
		
		System.out.println(s.getName() + "----" + s.getAge() + "----" + s.getsId() + "----" + s.getGender() + "----"
				+ s.getTitle());
	}
}

成员方法

* 类的组成中有一个成员:成员方法
*   成员方法的分类:
*     1)按照返回值划分
*      void的形式:没有具体的返回值
*      非void形式:有具体返回值
*     2)按照参数进行划分
*      空参
*      有参

//创建一个学生类
class Student {
	
	
	private String name ;
	private String age ;
	
	
	public Student() { //alt+shift+s+c
	}
	



	//成员方法
	public String show() { //有返回值没有参数的
		return "helloworld" ;
	}
	
	
	//没有返回值,有参数的情况
	public void method(String s) {
		System.out.println(s);
	}
	
	//没有返回值,没有参数的情况
	public void function() {
		System.out.println("function student...");
	}
	
	//有返回值,有参数的情况
	public String function2(String s1,String s2) {
		return s1+ s2;
	}
}

//测试类
public class Test {

	public static void main(String[] args) {
	
		//创建学生类对象
		Student s = new Student() ;
		
		String str = s.show() ;
		System.out.println(str);
		s.method("Java");
		s.function();
		String str2 = s.function2("hello", "world") ;
		System.out.println(str2);
		
	}
}

构造方法

* 构造方法作用:
*   就是给对象进行进行初始化
*
* 构造方法也属于一类的组成:
*    成员变量
*    构造方法
*    成员方法
*
* 构造方法:
*   1)方法名和类名相同
*   2)构造方法,连void都没有

* 构造方法的注意事项:
* 1)之前没有写无参构造,系统会默认提供无参构造
* 2)如果我们无参构造或者有参构造,系统不会在提供无参构造;定义一个类的时候,永远给出无参构造;
*
*
* 构造方法是可以重载的:

//创建一个老师类
class Teacher{
	
	private String name ;
	private int age ;
	
	//SetXXX()/GetXXX()方法:公共访问方法
	
	public String getName() {
		return name;
	}

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

	public int getAge() {
		return age;
	}

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

	//无参构造
	public Teacher() {
		System.out.println("老师类的无参构造..");
	}
	
	//有参构造
	public Teacher(String name) {
		this.name = name;
		
		System.out.println("带一个String类型参数的有参构造");
	}
	
	public Teacher(int age) {
		this.age =age ;
		System.out.println("带一个int类型参数的有参构造");
	}
	
	//带两个参数
	public Teacher(String name,int age) {
		this.name =name ;
		this.age = age ;
		System.out.println("带两个参数的有参构造...");
	}
}

//测试类
public class ConstructorDemo2 {

	public static void main(String[] args) {
		
		//创建一个老师类对象
		Teacher t = new Teacher() ; 
		t.setName("张三");
		t.setAge(27);
		System.out.println(t.getName()+"----"+t.getAge());
		System.out.println("----------");
		
		/**
		 * 给成员变量有两种方式:
		 * 	1)setXXX()公共的访问方法
		 * 	2)可以通过有参构造进行赋值
		 */
		t = new Teacher("高圆圆") ; 
		t.setAge(28);
		System.out.println(t.getName()+"----"+t.getAge());
		System.out.println("----------------");
		
		t= new Teacher(27) ;
		t.setName("赵又廷");
		System.out.println(t.getName()+"----"+t.getAge());
		
		System.out.println("----------------");
		
		Teacher t2 = new Teacher("高圆圆", 27) ;
		System.out.println(t2.getName()+"----"+t2.getAge());
		
		
		
		
		
	}
}

Tunaep

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
数组面向对象的知识和技术总结

数组 * 数组:可以存储多个元素并且多个元素是同一种类型的容器 * * 数组的定义: * 数据类型[] 数组名; * 数据类型数组名[]; * * 举例: * int[] a; 定义了一个int类型的数组变量a * int a[] ; 定义了一个int类型变量a数组 * * 这两种方式的定义:虽然写法不一样,并且读法不一样,...
复制链接

扫一扫