Java面向对象编程_方法&类与对象&数组&String类

Java面向对象编程_1

---

总览：

---

1，方法

2，类与对象

demo_static方法

class data
{
	private int num;
	private String job;
	private String spot;
	static String country="中华民国";
	public static String countryInfo()//static方法调用static属性
	{
		return "国籍："+country;
	}

	public data(){}
	public data(int num,String job,String spot)
	{
		this.num=num;
		this.job=job;
		this.spot=spot;
	}
	public void setNum(int num)
	{
		this.num=num;
	}
		public void setJob(String job)
	{
		this.job=job;
	}
		public void setSpot(String spot)
	{
		this.spot=spot;
	}
	public int getNum()
	{
		return this.num;
	}
	public String getJob()
	{
		return this.job;
	}
	public String getSpot()
	{
		return this.spot;
	}
	public String dataInfo()
	{
		return "编号："+this.num+" 部门："+this.job+" 地点："+this.spot+countryInfo();//非static方法调用static方法
	}
}

public class Static
{
	public static void main(String agrs[])
	{
		System.out.println( data.countryInfo());//static方法的类名调用。
		data a=new data(001,"财务科","北京");
		a.country="中华人民共和国";
		System.out.println(a.dataInfo());
	}
}

demo_代码块

class A
{
	static {//静态代码块
		System.out.println("【静态代码块】在子类中用于初始化，先于构造块执行");
	}
	{
		System.out.println("【构造代码块】在子类中用于初始化，先于构造方法执行");
	}
	public A(){
		System.out.println("【构造方法】执行");

	}

}
public class 代码块
{
	static{//静态代码块
		System.out.println("【静态代码块】在主类中用于初始化，先于main方法执行");			
	}
	public static void main(String agrs[]){
		{//普通代码块
			int a=100;
			System.out.println("【普通代码块】"+a);
		}
		int a=0;
		new A();

	}
}

demo_简单Java类

class Employee
{
	private String empnum;
	private String empname;
	private double empsalary;
	private double emprate;

	//setter与getter方法略
	public Employee(){}
	public Employee(String empnum,String empname,double empsalary,double emprate){
		this.empnum=empnum;
		this.empname=empname;
		this.empsalary=empsalary;
		this.emprate=emprate;
	}
	public String empInfo(){
		return "编号："+empnum+" 姓名："+empname+" 薪水："+empsalary+" 增长率："+emprate;
	}
	public String salaryInfo(){
		return " 薪水增长值："+(this.empsalary * this.emprate)+" 增长后的薪水："+(this.empsalary*(1+this.emprate));
	}
}
public class 简单java类_2{
	public static void main(String agrs[]){
		Employee emp=new Employee("0001","李华",2000,0.2);
		System.out.println(emp.empInfo()+emp.salaryInfo());

	}
}

3，数组

demo_二维数组

public class 二维数组
{
	public static void main(String agrs[]){
		int data[][]=new int [][]{
			{1,2,3},{4,5,6,7,8},{9,10}
		};
		for(int temp[]:data){
			for(int num:temp){
				System.out.print(num);
			}
			System.out.println();
		}
	}
}

demo_数组与方法

class Array{
	private int max;
	private int min;
	private int sum;
	private	int i;
	public Array(){}
	public Array(int data[]){
		this.max=data[0];
		this.min=data[0];
		for(i=0;i<data.length;i++){
			this.sum+=data[i];
			if(this.max<data[i])
				this.max=data[i];
			if(this.min>data[i])
				this.min=data[i];
		}
	}
	public String arrayInfo(){
		return "最大值："+this.max+" 最小值："+this.min+" 总和："+this.sum+" 平均值："+(this.sum/(i));
	}
}
public class 数组与方法
{
	public static void main(String agrs[]){
		int data[]=new int[]{1,2,3,4,5};
		System.out.println(new Array(data).arrayInfo());
	}
}

demo_数组倒置

class Array
{
	public static void arrayAction(int data[]){
		int head=0;
		int tail=data.length-1;
		for(int i=0;i<data.length/2;i++){
			int temp=data[head];
			data[head]=data[tail];
			data[tail]=temp;
			head++;
			tail--;
		}
	}
	public static void printArray(int data[]){
		for(int temp :data){
			System.out.print(temp);
		}
	}
}
public class 数组倒置
{
	public static void main(String agrs[]){
		int a[]=new int[]{1,2,3,4,5,6,7};
		Array.arrayAction(a);
		Array.printArray(a);
	}
}

demo_数组相关类库

class Array
{
	public static void printArray(int data[]){
		for(int temp:data){
			System.out.print(temp+" ");
		}

	}
}
public class 数组相关类库
{
	public static void main(String agrs[]){
		int a[]=new int[]{54,84,92,84,2,69,89,102};
		java.util.Arrays.sort(a);//系统类库数组排序
		Array.printArray(a);
		int b[]=new int[]{1,2,3,4,5};
		int c[]=new int[]{11,22,33,44,55};
		System.arraycopy(c,1,b,1,2);//系统类库数组拷贝
		Array.printArray(b);//输出结果：1 22 33 4 5
	}
}

demo_对象数组

class person
{
	private String name;
	private int age;
	//setter,getter略
	public String personInfo(){
		return "姓名："+this.name+" 年龄："+this.age;
	}
	public person(String name,int age){
		this.name=name;
		this.age=age;
	}
}
public class 对象数组
{
	public static void main(String agrs[]){
		person per[]=new person[]{new person("a",1),new person("b",2),new person("c",3)};
		for(int i=0;i<per.length;i++){
			System.out.println(per[i].personInfo());
		}
	}
}

demo_类关联结构

class Car
{
	private String name;
	private double price;
	private Person person;
	public Car(String name,double price){
		this.name=name;
		this.price=price;
	}
	public void setPerson(Person person){
		this.person=person;
	}
	public String carInfo(){
		return "车辆型号："+this.name+" 价格："+this.name;
	}
	public Person getPerson(){
		return this.person;
	}

}
class Person
{
	private String name;
	private int age;
	private Car car;
	private Person children[];//孩子可能有多个
	public Person(String name,int age){
		this.name=name;
		this.age=age;
	}
	public void setCar(Car car){
		this.car=car;
	}
	public String personInfo(){
		return "姓名："+this.name+" 年龄："+this.age;
	}
	public Car getCar(){
		return this.car;
	}
	public void setChildren(Person children []){
		this.children=children;
	}
	public Person[] getChildren(){
		return this.children;
	}
}

public class 类关联结构
{
	public static void main(String agrs[]){
		Person per=new Person("张三",18);
		Person childA=new Person("a",10);
		Person childB=new Person("b",11);
		childA.setCar(new Car("车1",20.0));
		childB.setCar(new Car("车2",30.0));
		per.setChildren(new Person[]{childA,childB});
		Car car=new Car("劳斯莱斯",2000000000.0);
		per.setCar(car);
		car.setPerson(per);
		System.out.println(per.getCar().carInfo());//代码链
		System.out.println(car.getPerson().personInfo());
		for(int i=0;i<per.getChildren().length;i++){
			System.out.println(per.getChildren()[i].personInfo());
			System.out.println(per.getChildren()[i].getCar().carInfo());
		}


	}
}

demo_类关联结构2

class Person
{
	private int pid;
	private String name;
	private Role role[];
	
	public Person(int pid,String name){
		this.pid=pid;
		this.name=name;
	}
	public String getInfo(){
		return "用户编号："+this.pid+" 用户姓名："+this.name;
	}
	public void setRole(Role[] role){
		this.role=role;
	}
	public Role [] getRole(){
		return this.role;
	}

}
class Role
{
	private int rid;
	private String name;
	private Person person[];
	private Privilege privilege[];

	public Role(int rid,String name){
		this.rid=rid;
		this.name=name;
	} 
	public String getInfo(){
		return "角色编号："+this.rid+" 角色名称："+this.name;
	}
	public void setPerson(Person[] person){
		this.person=person;
	}
	public Person [] getPerson(){
		return this.person;
	}
	public void setPrivilege(Privilege[] privilege){
		this.privilege=privilege;
	}
	public Privilege [] getPrivilege(){
		return this.privilege;
	}
}
class Privilege
{
	private int id;
	private String name;
	private Role role;

	public Privilege(int id,String name){
		this.id=id;
		this.name=name;
	}
	public String getInfo(){
		return "权限编号："+this.id+" 权限名称："+this.name;
	}
	public void setRole(){

		this.role=role;
	}
	public Role getRole(){
		return this.role;
	}

}
public class 类关联结构_2
{
	public static void main(String agrs[]){
		Person per1=new Person(1,"张三");
		Person per2=new Person(2,"李四");
		Role role1=new Role(1001,"系统配置员");
		Role role2=new Role(2001,"系统备份员");
		Role role3=new Role(3001,"人事管理员");
		Privilege pri1=new Privilege(1001,"系统采购");
		Privilege pri2=new Privilege(1002,"系统安装");
		Privilege pri3=new Privilege(2001,"系统维护");
		Privilege pri4=new Privilege(2002,"系统备份");
		Privilege pri5=new Privilege(3001,"人员招聘");
		Privilege pri6=new Privilege(3002,"人员离职");
		
		per1.setRole(new Role[]{role1,role2});
		per2.setRole(new Role[]{role1,role3});
		role1.setPerson(new Person[]{per1,per2});
		role2.setPerson(new Person[]{per1});
		role3.setPerson(new Person[]{per2});
		role1.setPrivilege(new Privilege[]{pri1,pri2});
		role2.setPrivilege(new Privilege[]{pri3,pri4});
		role3.setPrivilege(new Privilege[]{pri5,pri6});
		pri1.setRole(role1);
		pri2.setRole(role1);
		pri3.setRole(role2);
		pri4.setRole(role2);
		pri5.setRole(role3);
		pri6.setRole(role3);

		System.out.println("-----------------------以用户搜索角色与其对应权限---------------------");
		System.out.println(per1.getInfo());
		for(int i=0;i<per1.getRole().length;i++){
			System.out.println("\t|-"+per1.getRole()[i].getInfo());
			for(int j=0;j<per1.getRole()[i].getPrivilege().length;j++){
				System.out.println("\t\t|-"+per1.getRole()[i].getPrivilege()[j].getInfo());	
			}
		}
		System.out.println(per2.getInfo());
		for(int i=0;i<per2.getRole().length;i++){
			System.out.println("\t|-"+per2.getRole()[i].getInfo());
			for(int j=0;j<per2.getRole()[i].getPrivilege().length;j++){
				System.out.println("\t\t|-"+per2.getRole()[i].getPrivilege()[j].getInfo());	
			}
		}
		System.out.println("-----------------------以角色搜索用户---------------------");
		System.out.println(role1.getInfo());
		for(int i=0;i<role1.getPerson().length;i++){
			System.out.println("\t|-"+role1.getPerson()[i].getInfo());
		}
		System.out.println(role2.getInfo());
		for(int i=0;i<role2.getPerson().length;i++){
			System.out.println("\t|-"+role2.getPerson()[i].getInfo());
		}
		System.out.println(role3.getInfo());
		for(int i=0;i<role3.getPerson().length;i++){
			System.out.println("\t|-"+role3.getPerson()[i].getInfo());
		}
		System.out.println("-----------------------以角色搜索权限---------------------");
		System.out.println(role1.getInfo());
		for(int i=0;i<role1.getPrivilege().length;i++){
			System.out.println("\t|-"+role1.getPrivilege()[i].getInfo());
		}
		System.out.println(role2.getInfo());
		for(int i=0;i<role2.getPrivilege().length;i++){
			System.out.println("\t|-"+role2.getPrivilege()[i].getInfo());
		}
		System.out.println(role3.getInfo());
		for(int i=0;i<role3.getPrivilege().length;i++){
			System.out.println("\t|-"+role3.getPrivilege()[i].getInfo());
		}

	}
}

4，String类

demo_字符串池

public class String类
{
	public static void main(String agrs[]) {
		// public:方法访问权限是公共的，主方法一定是公共的。static:程序的执行是通过类名称调用的。void:主方法是一切的起点，起点一旦开始就没有返回的可能。main:系统定义好的主方法。String agrs[]:可以实现程序启动函数的接收
		//对于启动参数的接收：在java 文件名时后加参数，不同参数之间用空格隔开，参数本身有空格的用双引号引起来
		for(String temp:agrs){
			System.out.println(temp);
		}


		String str1="ok";
		String str2=new String("ok");
		System.out.println(str1==str2);//"=="主要在数值方面对比，在对象（此处String类）比较方面比较的是堆内存地址
		System.out.println(str1.equals(str2));//调用java类库String中的类方法equals();来比较字符串
		//一般的null的字符串编译器会报错，但equals()方法所创建的字符串为null时不报错

		String strA="ok";//直接赋值：创造一个实例化对象，并且将其放入字符串池中实现字符串的重用
		String strB=new String("ok");//构造方法：创造两个实例化对象new一个“”一个，不将其放入字符串池，造成其中一个实例化对象成为内存垃圾
		System.out.println(strA==strB);
		String strC=new String("ok").intern();//intern();方法实现手动入池（池中相同字符串公用一池）
		System.out.println(strA==strC);
		//字符串池分两种：静态字符串池：运行前加载好的字符串池（条件：都是字符串常量组合）动态字符串池：运行时才加载（条件：含有字符串变量）
		String stra="hello word";//静态字符串池
		String strb="hello"+" word";//静态字符串池
		String info="hello";
		String strc=info+" word";//动态字符串池
		System.out.println(stra==strb);
		System.out.println(stra==strc);

	}
}

demo_字符串常用方法

public class String类常用方法
{
	public static void main(String agrs[]){
	//字符串比较：
	//1.字符串.equals(字符串)【区分大小写】
	//2.字符串.equalsIgnoreCase(字符串)【不区分大小写】
	//3.字符串.compareTo(字符串)【返回其字符串的编码差值】4.字符串.compareToIgnoreCase(字符串)【不区分大小写】

	//字符串与字符（中文处理）：
	//1.public String?(char[] value)【（构造）全部字符数组->字符串】
	//2.public String(char[] value,int offset【开始】,int count【长度】)【（构造）部分字符数组（开始，长度）->字符串】
	//3.public char charAt(int index)【（普通）获取字符串索引位置（数组下标）的字符】
	//4.public char[] toCharArray()【（普通）将字符串数据以字符数组的形式输出】

	//字符串与字节（二进制数据传输or编码转换）：
	//1.public String(byte[] bytes)【（构造）全部字节数组->字符串】
	//2.public String(byte[] bytes,int offset,int length)【（构造）部分字符数组（开始，长度）->字符串】
	//3.public byte[] getBytes()【（普通）字符串->字节数组】
	//4.public byte[] getBytes(String charsetName)【（普通）编码转换】
		
	//字符串查找：
	//1.（JDK1.5后）public boolean contains(String s)【（普通）判断字符串是否存在】
	//2.（JDK1.5前）public int indexOf(String str)【（普通）从头查找指定字符串的位置：找不到返回-1，找到了返回对应字符数组下标】
	//3.public int indexOf(String str,int fromIndex)【（普通重载）从指定位置向后查找指定字符串：找不到返回-1，找到了返回对应字符数组下标】
	//4.public int lastIndexOf(String str)【（普通）从尾查找指定字符串的位置：找不到返回-1，找到了返回对应字符数组下标】
	//5.public int lastIndexOf(String str,int fromIndex)【（普通）从指定位置向前查找指定字符串：找不到返回-1，找到了返回对应字符数组下标】
	//6.public boolean startsWith(String prefix)【（普通）判断是否以指定字符串开头】
	//7.public boolean startsWith(String prefix，int toffset)【（普通重载）由指定位置判断是否以指定字符串开头】
	//8.public boolean endsWith(String suffix)【（普通）判断是否以指定字符串结尾】

	//字符串替换：
	//1.public String replaceAll(String regex,String replacement)【（普通）全部替换】
	//2.public String replaceFirst(String regex,String replacement)【（普通）替换首个】

	//字符串拆分：
	//1.public String[] split(String regex)【（普通）按照指定的字符串（规则）全部拆分并返回字符数组】
	//2.public String[] split(String,int limit)【（普通重载）按照定的字符串（规则）拆分成指定的个数，后面的不拆了并返回字符数组】
	//若出现无法拆分的情况用“\\”转义指定的字符（规则）

	//字符串截取：
	//1.public String substring(int beginIndex)【（普通）从指定索引截取到结尾】
	//2.public String substring(int beginIndex,int endIndex)【（普通重载）截取指定索引范围中的子字符串】

	//字符串格式化：
	//1.public static String format(String format,各种类型 args)【（普通）类似于C语言的格式化输出】
	
	//字符串其他操作方法：
	//1.public String isEmpty()【（普通）判断是否为空字符（不是null而是“”）】
	//2.public int length()【（普通）】
	//3.public String trim()【（普通）删除左右空格】
	//4.public String toUpperCase()【（普通）转大写】
	//5.public String toLowerCase()【（普通）转小写】

	}
}