【名师课堂】Java面向对象开发

【名师课堂】Java面向对象开发

Java核心第二部
106课时 |
23947人已学 |
(24 评论)

加入学习
加入学习

数组基本概念

数组在开发之中一定会使用,但是像以下讲解的时候这么用的数组少了.在以后的实际开发之中,你们会更多的使用数组概念,而直接使用数组99%的情况下都只是做一个数组的for循环输出.

如果说现在要求你定义100个整型变量,那么按照之前的一个做法,可能现在定义的结构如下:

int i1,i2,i3....i100;

但是这个时候如果按照此类方式定义就会非常麻烦,因为这些变量彼此之间没有任何的关联,也就是说如果现在突然再有一个要求,要求你输出这100个变量的内容,意味着你需要编写System.out.println()语句100次。

所谓的数组指的就是一组相关类型的变量集合,并且这些变量可以按照统一的方式进行操作。数组本身属于我们的引用数据类型,那么既然是引用数据类型,这里面实际上又会牵扯到内存分配,而数组的定义有如下两类。

 1. 数组的动态初始化:

  • 声明并开辟数组:
数据类型 [] 数组名称 = new 数据类型 [长度];
数据类型 数组名称 [] = new 数据类型 [长度];
  • 分布进行数组空间开辟(实例化)
//声明数组:
数据类型 [] 数组名称 = null;  //或者下面
数据类型 数组名称 [] = null; 

//开辟数组空间
数组名称 = new 数据类型 [长度];

那么当数组开辟空间之后,就可以采用如下的方式进行操作:

  • 数组的访问通过索引完成,即:数组名称[索引];但是需要注意的是,数组的索引从0开始,所以可以使用的索引范围就是 0~数组长度-1,例如:现在开辟了3个空间的数组,所以可以使用的索引是:0,1,2;如果此时数组访问的时候超过了数组的索引范围,则会产生"ArrayIndexOutOfBoundsException"异常信息;
  • 当数组采用动态初始化开辟空间之后,数组里面的每一个元素都是该数组对应数据类型的默认值;
  • 数组本身是一个有序的集合操作,所以对于数组的内容操作往往采用循环的模式完成,数组是一个有限的数据集合,所以应该使用for循环.
  • 在java中提供有一种动态取得数组长度的方法:数组名称.length;

范例:定义一个int数组

//开辟一个数组
public class Class15{
	public static void main(String args[]) {
		int data [] = new int [3];//开辟了一个数组长度为3的数组空间
		data[0] = 10;//第一个元素赋值
		data[1] = 11;//第二个元素赋值
		data[2] = 12;//第三个元素赋值
		//data.length 可以获取到该数组的长度
		for(int i = 0;i < data.length;i++) {
			System.out.println(data[i]);
		}
	}
}

数组本身除了声明并开辟空间之外还有另外一种开辟模式.

 

范例:采用分布模式开辟数组空间

//分布式开辟一个数组
public class Class16{
	public static void main(String args[]) {
		int data [] = null;//声明
		data = new int [3];//开辟了一个数组长度为3的数组空间
		data[0] = 10;//第一个元素赋值
		data[1] = 11;//第二个元素赋值
		data[2] = 12;//第三个元素赋值
		//data.length 可以获取到该数组的长度
		for(int i = 0;i < data.length;i++) {
			System.out.println(data[i]);
		}
	}
}

但是千万要记住,数组属于引用数据类型,所以在数组使用之前一定要开辟空间(实例化),如果使用了没有开辟空间的数组,则一定会出现NullPointException异常信息:

public class Class16{
	public static void main(String args[]) {
		int data [] = null;//声明
		System.out.println(data.length);
	}
}

这一原则和之前讲解的对象操作是完全相同的.

 

 

 

[展开全文]

第一个代码模型:简单java类

现在假设有这样一个要求,定义一个雇员类,该类中会包含雇员编号,姓名,职位,基本工资,佣金几个属性信息。

那么这种类称为简单java类,既然是简单java类就有自己明确的开发要求:

  • 类名称应该有意义,可以明确的描述出某一类,例如:Emp,Member,Dept;
  • 类中的所有属相必须使用private封装,所有的属性必须按照要求提供setter,getter方法;
  • 类中可以定义若干个构造方法,但是必须保留有一个无参构造方法;
  • 类中的所有方法都不允许出现任何的System.out语句,所有的输出必须交给调用处完成。
  • 类中应该提供一个返回类完整信息的方法,这个方法名称暂时为getInfo()。
范例:编写程序类
//简单java类
class Student{
	private int id;
	private String name;
	private String sex;
	private int grade;
	private double score;
	public Student(int i,String n,String s,int g,double so) {
		setId(i);
		setName(n);
		setSex(s);
		setGrade(g);
		setScore(so);
	}
	public void setId(int i) {
		id = i;
	}
	public void setName(String n) {
		name = n;
	}
	public void setSex(String s) {
		sex = s;
	}
	public void setGrade(int g) {
		grade = g;
	}
	public void setScore(double so) {
		score = so;
	}
	public int getId() {
		return id;
	}
	public String getName() {
		return name;
	}
	public String getSex() {
		return sex;
	}
	public int getGrade() {
		return grade;
	}
	public double getScore() {
		return score;
	}
	public String getInfo() {
		return "id= " + id + ",name= " + name + ",sex= " + sex + ",grade = " + grade +",score = " + score; 
	}
}
public class Class14{
	public static void main(String args[]) {
		Student kai = new Student(1,"wangkai","man",2,90.0);
		System.out.println(kai.getInfo());
	}
}

 

涵盖了之前所讲解的面向对象概念。
 
  1. 以后的开发中搞得最多的就是简单java类,从基础的web开发,到分布式开发,到处都是简单java类。
  2. 开发原则一定要记牢。
[展开全文]

构造方法与匿名对象

在之前讲解了实例化对象的产生格式:

  • ①类名称 ②对象名称 = ③new ④类名称();
对于以上的格式观察组成部分:
  • ①类名称:任何的对象都应该有其对应的类,因为没有类就不知道对象具备的功能;
  • ②对象名称:是一个唯一的标记,表示的是以后的操作的属性的标记;
  •  ③new:表示开辟新的堆内存空间;
  • ④类名称():构造方法。
通过以上的分析就应该已经清楚了,所谓的构造方法指的就是在使用关键字new实例化新对象的时候来调用的操作方法,但是对于构造方法定义也需要遵守如下原则:方法名称必须与类名称相同,并且构造方法没有返回值类型声明,同时每一个类中一定会至少存在有一个构造方法,如果类中没有明确的定义任何一个构造方法,那么将自动生成一个无参的,什么都不做的构造方法。
 
范例:定义一个无参的什么都不做的构造方法
 
//在类中定义构造函数
class Person10{//定义一个类,类名称要求首字母大写
	private String name = "wangkai";
	private int age = 23;
	public Person10() {//构造函数,与类名称同名,并且构造方法没有返回值类型声明
		System.out.println("***********");
	}
	public void setName(String n) {
		name = n;
	}
	public void setAge(int a) {
		if(a > 0 && a < 150) {
			age = a;
		}else {
			age = 0;
		}
		
	}
	public String getName() {
		return name;
	}
	public int getAge() {
		return age;
	}
	public void info() {
		System.out.println("name = "+ name + ",age = " + age);
	}
}
public class Class10{
	public static void main(String args[]) {
	    //类名称 对象名称 = new 类名称();
		Person10 per1 = new Person10();//声明一个新的对象
		per1.setName("wangkai");
		per1.setAge(160);
		per1.info();
	}
}

疑问:既然构造方法中没有返回数据,为什么不使用void定义呢?

现在的类中的组成:属性,普通方法,构造方法。

  • 属性是在对象开辟堆内存的时候就开辟的空间。
  • 构造方法是在使用关键字new同时调用的;
  • class Person{
          public Person(){//这是一个构造方法,结构与普通方法截然不同,无返回值声明;
          }
    }
  •  
  • 普通方法是在对象已经实例化完成了(空间开辟了,构造方法执行了)再调用的,可以调用多次;
  • class Person(){
            public void Person(){//这是一个普通方法,虽然命名不标准;
            }
    }

     

对于类中可以自动生成的无参构造函数方法实际上是有一个前提的:你类中没有定义任何的构造方法,相反,如果你现在类中已经定义了构造方法,那么此类默认的构造方法将不会自动生成。
 
范例:类中定义一个有参构造方法
//在类中定义一个有参数的构造函数
class Person11{//定义一个类,类名称要求首字母大写
	private String name = "wangkai";
	private int age = 23;
	public Person11(String n,int a) {//构造函数,与类名称同名,并且构造方法没有返回值类型声明
		name = n;//setName(n)
		setAge(a);
	}
	public void setName(String n) {
		name = n;
	}
	public void setAge(int a) {
		if(a > 0 && a < 150) {
			age = a;
		}else {
			age = 0;
		}
		
	}
	public String getName() {
		return name;
	}
	public int getAge() {
		return age;
	}
	public void info() {
		System.out.println("name = "+ name + ",age = " + age);
	}
}
public class Class11{
	public static void main(String args[]) {
	    //类名称 对象名称 = new 类名称();
		Person11 per1 = new Person11("wangkai",30);//声明一个新的对象
		per1.info();
	}
}

构造方法的作用

1. 构造方法的调用和对象内存分配几乎是同步完成的,所以可以利用构造方法设置类中的属性内容,构造方法可以为类中的属性进行初始化处理;

2. 通过构造方法设置内容实际上就可以避免重复的setter调用了。

  • setter方法除了具备有设置内容之外,也可以承担修改数据的操作;
既然构造方法本身属于方法,那么方法就一定可以进行重载,而构造方法的重载更加简单,因为方法名称就是类名称,你能够做的只有实现参数的类型或个数不同这一概念。
 
范例:构造方法重载
//构造函数重载
class Person12{//定义一个类,类名称要求首字母大写
	private String name;
	private int age;
	public Person12() {
		
	}
	public Person12(String n) {
		name = n;
	}
	public Person12(String n,int a) {//构造函数,与类名称同名,并且构造方法没有返回值类型声明
		name = n;//setName(n)
		setAge(a);
	}
	public void setName(String n) {
		name = n;
	}
	public  void setAge(int a) {
		if(a > 0 && a < 150) {
			age = a;
		}else {
			age = 0;
		}
		
	}
	public String getName() {
		return name;
	}
	public int getAge() {
		return age;
	}
	public void info() {
		System.out.println("name = "+ name + ",age = " + age);
	}
}
public class Class12{
	public static void main(String args[]) {
	    //类名称 对象名称 = new 类名称();
		Person12 per1 = new Person12("wangkai");//声明一个新的对象
		per1.setAge(23);
		per1.info();
	}
}

在进行构造方法重载的时候请注意以下定义结构。建议若干个构造方法按照参数的个数采用升序或降序排列。

同时也需要注意一点:在进行类定义的时候,请按照如下顺序完成:

  • 第一部分写属性;
  • 第二部分写构造方法;
  • 第三部分写普通方法;
发现构造方法可以传递属性的内容了,那么很多时候为了使用方便,往往会使用匿名对象完成。
 
范例:匿名对象
//匿名对象
class Person13{//定义一个类,类名称要求首字母大写
	private String name;
	private int age;
	public Person13(String n,int a) {//构造函数,与类名称同名,并且构造方法没有返回值类型声明
		name = n;//setName(n)
		setAge(a);
	}
	public void setName(String n) {
		name = n;
	}
	public  void setAge(int a) {
		if(a > 0 && a < 150) {
			age = a;
		}else {
			age = 0;
		}
		
	}
	public String getName() {
		return name;
	}
	public int getAge() {
		return age;
	}
	public void info() {
		System.out.println("name = "+ name + ",age = " + age);
	}
}
public class Class13{
	public static void main(String args[]) {
	    //类名称 对象名称 = new 类名称();
		new Person13("wangkai",23).info();//匿名对象
	}
}

因为匿名对象不会有任何的栈空间所指向,所以使用一次之后就将成为垃圾。

你现在是否使用匿名对象没有绝对定论,你一切都可以使用有名对象。

 

  1. 构造方法每个类中至少存在一个;
  2. 构造方法的名称与类名称相同,无返回值类型定义你;
  3. 构造方法允许重载,重载时只需要考虑方法的参数类型或个数即可。
[展开全文]
里程碑 · 2017-12-24 · 构造方法与匿名对象 0

private(私有)实现封装处理

面向对象之中有三大主要特征:封装,继承,多态,对于封装是整个java中最复杂的概念,而此次所讲的内容也不过是封装中的基本概念而已。

要想清楚封装,首先必须清楚如果没有封装会怎样。

范例:观察如下的一个程序

//观察如下程序
class Person{//定义一个类,类名称要求首字母大写
	String name;
	int age;
	public void info() {
		System.out.println("name = "+ name + ",age = " + age);
	}
}
public class Class5{
	public static void main(String args[]) {
	    //类名称 对象名称 = new 类名称();
		Person per1 = new Person();//声明一个新的对象
		per1.name = "wangkai";
		per1.age = -230;
		per1.info();
	}
}

这个程序实际上是不会出现任何的语法错误的,因为从int型的数据保存范围来讲,是允许保存有负数的。但是不会有一个人的年龄是-230,那么这个时候也就证明这个时候属于业务逻辑出错。

此时如果要想回避此类问题,那么首先要解决的就是如何可以让对象不能够直接操作年龄的属性,或者说是如何让类的外部不能够操作类中的敏感内容。所以此时解决问题的核心概念就在于:如何让内部的操作对外部不可见,此时就可以使用private关键字来实现。

范例:利用private来实现封装

//用private实现封装
class Person1{//定义一个类,类名称要求首字母大写
	private String name = "wangkai";
	private int age = 23;
	public void info() {
		System.out.println("name = "+ name + ",age = " + age);
	}
}
public class Class6{
	public static void main(String args[]) {
	    //类名称 对象名称 = new 类名称();
		Person1 per1 = new Person1();//声明一个新的对象
		per1.info();
	}
}

类中的属性和方法上都可以使用private定义,但是大部分情况下很少会在方法上使用private。一旦属性的声明上使用了private定义之后,那么如果其他类直接进行该属性访问的时候就将出现如下的错误提示:

Exception in thread "main" java.lang.Error: Unresolved compilation problems: 
	The field Person2.name is not visible
	The field Person2.age is not visible

此时使用了private声明之后属性安全了,外部无法直接操作了,但是新的问题又来了。那么如果现在要想进行private私有属性的访问,按照java是设计原则就可以使用setter,getter访问:

  • setter方法:主要用于进行属性内容的设置;
          private String name:public void setName(String n)
  • getter方法:主要用于属性内容的取得;
          private String name: public void getName()
 
范例:扩展person类中的内容
//setter,getter
class Person8{//定义一个类,类名称要求首字母大写
	private String name = "wangkai";
	private int age = 23;
	public void setName(String n) {
		name = n;
	}
	public void setAge(int a) {
		age = a;
	}
	public String getName() {
		return name;
	}
	public int getAge() {
		return age;
	}
	public void info() {
		System.out.println("name = "+ name + ",age = " + age);
	}
}
public class Class8{
	public static void main(String args[]) {
	    //类名称 对象名称 = new 类名称();
		Person8 per1 = new Person8();//声明一个新的对象
		per1.setName("wangkai");
		per1.setAge(23);
		per1.info();
	}
}

如果说现在非要进行检测,那么可以在setter里面完成。

范例:setter检测数据

//可以在setter里面检测数据是否符合要求
class Person9{//定义一个类,类名称要求首字母大写
	private String name = "wangkai";
	private int age = 23;
	public void setName(String n) {
		name = n;
	}
	public void setAge(int a) {
		if(a > 0 && a < 150) {
			age = a;
		}else {
			age = 0;
		}
		
	}
	public String getName() {
		return name;
	}
	public int getAge() {
		return age;
	}
	public void info() {
		System.out.println("name = "+ name + ",age = " + age);
	}
}
public class Class9{
	public static void main(String args[]) {
	    //类名称 对象名称 = new 类名称();
		Person9 per1 = new Person9();//声明一个新的对象
		per1.setName("wangkai");
		per1.setAge(160);
		per1.info();
	}
}

类的设计原则:

  • 以后再编写类的时候类中的属性必须使用private封装。而使用private封装的属性如果需要被外部所使用,那么按照格式定义相应的setter,getter方法。
private实现封装的最大特征在于:只允许本类访问,而不允许外部访问。
private只是封装的第一步。
[展开全文]
里程碑 · 2017-12-24 · private实现封装处理 0

2.4 引用传递初次分析

所有初学者最难的部分就是 引用传递分析。以后的开发之中都是引用传递。

引用传递的本质就在于别名,而这个别名只不过是放在了栈内存之中,即:一块堆内存可以被多个栈内存所指向。

范例:观察引用传递

//引用传递
class Person{//定义一个类,类名称要求首字母大写
	String name;
	int age;
	public void info() {
		System.out.println("name = "+ name + ",age = " + age);
	}
}
public class Class2{
	public static void main(String args[]) {
	    //类名称 对象名称 = new 类名称();
		Person kai = new Person();//声明一个新的对象
		kai.name = "王凯";
		kai.age = 23;
		Person wang = kai;
		wang.name = "小王";
		kai.info();
	}
}

此程序的执行观察时需要通过内存关系图来进行:

范例:观察引用传递

//引用传递
class Person{//定义一个类,类名称要求首字母大写
	String name;
	int age;
	public void info() {
		System.out.println("name = "+ name + ",age = " + age);
	}
}
public class Class4{
	public static void main(String args[]) {
	    //类名称 对象名称 = new 类名称();
		Person per1 = new Person();//声明一个新的对象
		Person per2 = new Person();
		per1.name = "wangkai";
		per1.age = 23;
		per2.name = "kai";
		per2.age = 23;
		per2 = per1;
		per2.name = "hello";
		per2.info();
	}
}

观察此时的内存分析图:

在程序开发过程之中,所谓的垃圾空间指的就是没有任何栈内存指向的堆内存空间,所有的垃圾空间将不定期被java中的垃圾收集器(GC,Garbage Collector)进行回收以实现内存空间的释放,不过从实际开发来讲,虽然java有提供gc,但是gc也会造成程序性能的下降,所以开发过程之中一定要控制你对象的产生数量,即:无用的对象尽可能的少产生。

 

 

 

[展开全文]

对象的产生分析

如果要进行对象的产生分析,那么首先就必须清楚引用类型。引用类型指的是内存空间的操作。而对于现在的内存主要会使用两块内存空间:

  • 堆内存空间:保存真正的数据,堆内存保存的是对象的属性信息;
  • 栈内存空间:保存的堆内存的地址,堆内存的操作权,如果想要简化理解,可以理解为保存的是对象名称;
所以按照之前的程序,那么现在就可以给出如下的内存参考图:
但是对于对象的产生实际上要知道一共会有两种一共会有两种格式,现在使用的是声明并实例化对象的格式,那么也可以使用分布的方式来完成。
 
class Person{//定义一个类,类名称要求首字母大写
	String name;
	int age;
	public void info() {
		System.out.println("name = "+ name + ",age = " + age);
	}
}
public class Class1{
	public static void main(String args[]) {
	    //类名称 对象名称 = new 类名称();
		Person kai = null;//声明一个新的对象
		kai = new Person();//实例化了一个对象
		kai.name = "wangkai";//设置对象中的属性
		kai.age = 23;
		kai.info();//调用方法
	}
}

分布式具体内存分析:

但是千万要记住一点,对象(所有的引用数据类型)必须在其开辟空间之后才可以使用。如果使用了未开辟内存空间的引用类型,则将出现NullPointrException:

class Person{//定义一个类,类名称要求首字母大写
	String name;
	int age;
	public void info() {
		System.out.println("name = "+ name + ",age = " + age);
	}
}
public class Class3{
	public static void main(String args[]) {
	    //类名称 对象名称 = new 类名称();
		Person kai = null;//声明一个新的对象
		kai.info();//调用方法
	}
}

这个时候我们只是声明了对象,而并没有为其开辟堆内存空间,而本程序在编译的时候不会产生任何的语法错误,但是在执行的时候会出现如下的错误提示:

Exception in thread "main" java.lang.NullPointerException
	at 类与对象.Class3.main(Class3.java:15)

“NullPointerException”是在你们整个的开发人生之中会一直陪伴到你最后的一个异常。只有引用数据类型(数组,类,接口)才会产生此类异常,以后出现了就根据错误的位置观察该对象是否实例化。

 

 

 

[展开全文]
里程碑 · 2017-12-24 · 类与对象(对象内存分析) 0

2.2 类与对象的定义

如果在程序之中要进行类的定义你可以使用class关键字完成,而定义的语法如下:

 

class 类名称 { //所有的程序都要求以“{}”作为分界符

          属性;

          属性;

          方法(){}

}

 

此时的方法不在由主类直接调用,而是要通过对象进行调用。

 

范例:定义类

class Person{
	String name;
	int age;
	public void info() {
		System.out.println("name = "+ name + ",age = " + age);
	}
}

在这个类中只是定义了两个属性和一个方法,特别需要注意的是,类中可以定义的属性数量和方法数量是没有限制的,而且在编写的时候,每一个方法中的代码尽量不要特别长。

类定义完成之后是不能够直接去使用的,如果要想使用类必须要产生对象,而对象的定义分为以下两种语法形式:

  • 声明并实例化对象:类名称 对象名称 = new 类名称();
  • 分步进行对象实例化:
           1.声明对象:类名称 对象名称 = null;
            2.实例化对象:对象名称 = new 类名称();
 
 
引用数据类型的最大特征在于内存的分配操作,只要出现有关键字new那么就只有一个解释:开辟新内存(内存是不可能无限开辟的,所以这个时候所谓的性能调优调整的就是内存问题)。
 
所有的对象只有实例化之后才可以真正的使用,而类的使用都是围绕着类进行的,那么此时就有两种形式:
  • 调用类中的属性:对象.属性 = 内容;
  • 调用类中的方法:对象.方法();
 
范例:声明并实例化对象
 
class Person{//定义一个类,类名称要求首字母大写
	String name;
	int age;
	public void info() {
		System.out.println("name = "+ name + ",age = " + age);
	}
}
public class Class{
	public static void main(String args[]) {
	    //类名称 对象名称 = new 类名称();
		Person kai = new Person();//这个时候就表示我们实例化了一个kai对象
		kai.name = "wangkai";//设置对象中的属性
		kai.age = 23;
		kai.info();//调用方法
	}
}

以上就实现了一个最基本的类的定义以及对象的使用。

[展开全文]
里程碑 · 2017-12-24 · 类与对象(类与对象定义) 1

类与对象基本定义

类与对象是整个面向对象设计的核心所在,也是所有概念的基础。类的本身属于引用数据类型,所以类的使用会牵扯到内存的分配问题。

 

认识类与对象

现在大家可以听懂本人说话,我们具备共同的特征:我们都是中国人,母语都是汉语,而且身体正常。具备这个特征的人很多,那么就自然是一个群体,而群体的特征就是整个类的定义概念。所谓的类描述的就是共性特征。

任何时候只是依靠共性特征是无法进行精准描述的,那么就需要一些个性化的特点。就可以描述一个个独立的事物。这样就可以推断出:所谓的类指的就是一个共性的概念,而对象指的是一个具体的可以使用的事物。

那么很明显,在实际的开发之中一定需要首先产生类,而后才可以产生对象。那么对象的所有操作行为都一定在类中进行了完整定义。类中没有定义的功能,那么对象一定是无法使用。

类中的组成:方法(操作的行为),属性(变量,描述每一个对象的具体特点)

全部笔记 --》》http://wangkai.xyz

 

 

 

 

 

[展开全文]

面向对象

面向对象是一种程序的设计方法,但是并不表示所有的开发者都认同面向对象。因为有很多开发者认为面向对象过于复杂,所以更多人愿意使用函数式编程。

 

面向对象的前生属于面向过程,如果要想笼统的去解释这两种开发模型的区别,最好的例子:面向过程是解决问题,而面向对象是模块化设计。对于现在的程序开发更多情况下就像是汽车组装一样,不同的工厂生产不同的配件。将所有的零件组装在一起就可以形成一辆汽车,并且当一个零件坏掉的时候还可以进行配装。

 

在面向对象里面实际上还有很多的特点,归结起来有如下三类:

  • 封装性:内部的操作对外部而言不可见;
  • 继承性:在上一辈的基础上继续发展;
  • 多态性:这是一个最为重要的概念,利用多态性才可以得到良好的设计;

那么在进行面向对象开发的时候也有三个阶段:OOA(面向对象分析),OOD(面向对象设计),OOP(面向对象编程)。

所有的程序的开发原则都离不开现实生活。如果从程序的开发角度来讲,面向对象给我们最大的特征:可以进行生活的抽象。

全部笔记请看 http://wangkai.xyz

[展开全文]
里程碑 · 2017-12-24 · 面向对象简介 0

字符串截取

从一个完整的字符串之中截取出部分内容,那么对于截取的方法,如下:

public String substring(int beginIndex)

从指定索引索引截取到最后

public String substring(int beginIndex,int endIndex)

截取部分内容:

范例:观察字符串的截取操作

String str = "helloworld";

System.out.println(str.substring(5));

System.out.println(str.substring(0,5));

千万记住了,程序中的字符串截取索引从0开始,而且只能设置正整数,不能使用负数。

[展开全文]
时光如流沙 · 2017-12-20 · String类的常用方法(字符串截取) 0

字符串拆分

在整个的字符串之中,可以使用一个特定的字符串来实现字符串的分割处理,也就是说可以将一个完整的字符串,按照指定的分隔符划分为若干个子字符串:

public String[] sqlit(String regex)

将字符串全部拆分

public String[] sqlit(String regex,int limit)

将字符串部分拆分,该数组长度就是limit长度的极限

范例:实现字符串的拆分处理

String str = "hello world hello mldn";

String result [] = str.split(" ");//按照空格拆分

for(int x = 0;x< result.length;x++){

System.out.println(result[x]);

}

范例:部分拆分

String str = "hello world hello mldn";

String result [] = str.split(" " , 2);/按照空格进行拆分,将字符串拆分为两段

for(int x = 0; x < result.length;x++){

System.out.println(result[x]);

}

已上的拆分形式都很容易,如果发现有些内容无法拆分开,就需要使用“\\”进行转义

范例:拆分ip地址

String str = "192.168.1.1";

String result [] = str.split("\\. " );/使用转义字符,才可拆分

for(int x = 0; x < result.length;x++){

System.out.println(result[x]);

}

在以后的实际开发之中,经常会出现这样的拆分模式:姓名:年龄|姓名:年龄|....

范例:

String str = "SMITH:10|ALLEN:20";

String result [] = str.split("\\|" );/使用转义字符,才可拆分

for(int x = 0; x < result.length;x++){

String temp [] = result[x].split(":");

System.out.println(temp[0] + "=" + temp[1]);

}

这个代码在以后的开发中会经常出现。

[展开全文]
时光如流沙 · 2017-12-20 · String类的常用方法(字符串拆分) 0

实例化对象的产生格式:

类名称 对象名称 = new 类名称();

对于以上的格式观察组成部分:

  1. 类名称:任何的对象都应该有对应的类,因为没有类就不知道对象具备的功能;
  2. 对象名称:是一个唯一的标记,表示的是以后操作的属性的标记;
  3. new:表示开辟新的堆内存空间;
  4. 类名称():构造方法。

所以通过以上分析可以清楚,所谓的构造方法指的就是在使用关键字new实例化新对象的时候来进行调用的操作方法,但是对于构造方法定义也需要遵守如下原则:方法名称必须与类名称相同,并且构造方法没有返回值类型声明,同时每一个类中一定会至少存在一个构造方法,如果类中没有一个构造方法,那么将自动生成一个无参的,什么都不做的构造方法。

类的组成:属性、普通方法、构造方法。

属性是在对象开辟堆内存的时候就开辟的空间;

构造方法是在使用关键字new的同时调用的;

普通方法是在对象实例化完成了(空间开辟了,构造方法执行了)再调用的,可以调用多次;

构造方法的作用:

构造方法的调用和兑现内存分配几乎是同步完成的,所以可以利用构造方法设置类中的属性内容,构造方法可以为类中的属性进行初始化处理;

通过构造方法设置内容实际上就可以避免重复的setter调用了。

在实际开发之中,setter方法除了具备有设置内容制外,还可以承担修改数据的操作。

既然构造方法本身属于方法,那么方法就一定可以进行重载,而构造方法的重载更加简单,因为方法名称就是类名称,所以可以做的只是实现参数的类型或个数不同这一概念。

在进行类定义的时候,注意以下:

  • 第一部分写属性;
  • 第二部分写构造方法;
  • 第三部分些普通方法;

由于匿名对象不会有任何的栈空间所指向,所以使用一次之后就将成为垃圾。

构造方法每个类中至少存在一个;

构造方法的名称与类名称相同,无返回值类型定义;

构造方法允许重载,重载时只需要考虑方法的参数类型或个数即可;

[展开全文]
时光如流沙 · 2017-12-13 · 构造方法与匿名对象 0

java.util.Arrays.sort();   

System.arraycopy(arr1,i,arr2,j,k)  

[展开全文]

class Simple {
    private String Name;
    private int Id;
    private int Age;
    public Simple(String s,int i,int a) {
        setName(s);
        setId(i);
        setAge(a);
    }
    public void setName(String name) {
        Name = name;
    }

    public String getName() {
        return Name;
    }

    public void setId(int id) {
        Id = id;
    }

    public int getId() {
        return Id;
    }

    public int getAge() {
        return Age;
    }

    public void setAge(int age) {
        Age = age;
    }

    public String getInfo() {
        return "Name=" + Name + "\n" + "Id=" + Id + "\n" + "Age=" + Age + "\n";
    }
}

public class SimpleJavaClass {
    public static void main(String args[]) {
        System.out.println(new Simple("Gft",32,22).getInfo()); 
    }
}

[展开全文]

引用传递初次分

引用传递的本质在于别名,一块堆内存可以被多个栈内存所指向。

Person per1=new Person();
per1.name="小宇子";
per1.age=30;
//此步骤就是引用传递的操作
Person per2=per1;//采用同样的类型接收
per2.name="狗剩";//设置一个名字
per1.info();

内存关系图

Person per1=new Person();
Person per2=new Person();
per1.name="小宇子";
per1.age=30;
per2.name="张三";
per2.age=20;
per2=per1;
per2.name="狗剩";
per2.age=30;
per1.info();

内存关系图

在程序开发过程中,所谓的垃圾空间指的就是没有任何栈内存指向的堆内存空间,所有的垃圾空间将不定期被java垃圾收集器(GC  Garbage Collector)进行回收以实现内存空间的释放,从实际开发来讲,虽然java有GC,但是GC会降低程序的性能,所以在开发中一定要控制好对象的产生数量,即:无用的对象尽可能少产生。

 

[展开全文]
致知格物 · 2017-11-01 · 类与对象(引用传递初次分析) 1

区别变量和方法的最简单方法是看有没有()

属性是在对象开辟堆内存空间的时候生成的

构造方法是在使用关键字new的时候同时调用的(只调用一次)

普通方法是在对象已经实例化完成了再调用的(可调用多次)

定义一个有参构造,则默认的无参构造将不会在编译时自动生成

构造方法的调用和对象内存分配几乎是同步完成的,构造方法可以对属性进行初始化处理

通过构造方法设置内容实际上就可以避免重复的setter操作

匿名对象:new Person("张三",30)info();

由于匿名对象不会有任何的栈空间所指向,所以使用一次后将成为垃圾

 

[展开全文]
errymouse · 2017-10-27 · 构造方法与匿名对象 0

如何使内部数据外部不可见,使用private实封装

类的设计原则:必须使用封装,如果需要对封装的对象进行操作,则需要对封装对象提供getter和setter方法

private实现封装的最大特征是只允许本类访问而不允外部类访问。

[展开全文]
errymouse · 2017-10-27 · private实现封装处理 0

引用传递本质在于别名,放在栈内存中,一个堆内存空间

当两个对象引用同一内存地址时,无论任何一方属性发生改变,另一方的属性也会同时发生改变

垃圾空间:没有任何栈内存指向的堆内存空间,将不定期的GC回收。

[展开全文]

内存空间:

1、堆内存空间:真正的数据,保存的是对象的属性信息

2、栈内存空间:保存堆内存的地址,对象名称

一个栈只能保存一个堆内存地址

对象必须为其开辟内存空间才能执行,否则会报空指针异常

[展开全文]
errymouse · 2017-10-27 · 类与对象(对象内存分析) 0

类:具有共同特性的群体(如:人)

对象:一个具体的可以使用的实物(如:一个叫王宝强的人)

首先需要产生类之后才能操作对象;类中定义好的对象都可以操作,类中没有定义的对象就一定不能操作。

类的组成:方法(操作的行为)、属性(变量,描述每一个对象的具体特点)

[展开全文]

授课教师

讲师
阿里云开发者社区全面升级
一站式体验,助力云上开发!
进入新社区

相关课程

查看更多 >