标签:读取 自动生成 加载 运行 ram zhang cte 静态代码块 string类
source:http://blog.java1234.com/index.html?typeId=1
Java面向对象三大特性;
封装:类,类里有方法,属性,可以封装很多功能 仅仅对外暴露一些接口,来实现模块化,组建化,和安全性;
继承:Java中的类可以继承,类似子女可以继承父母的东西;来实现可扩展;
多态:Java中的父类接口可以指向子类实现的引用;
类与对象的关系
通俗的举个例子,比如人类是一种类,张三这个人就是人类的具体的一个个体,也就是java中的对象;这就是一个类与对象的关系;
//新建一个Person类,java文件名和类名必须一致 public class Person { String name; // 在类中,定义一个姓名name字符串属性 可以存在字符串 类似"张三" int age; // 在类中,定义一个年龄age属性 /** * 定义一个方法 public表示共有 权限最大 void表示返回值是空 speak是方法名 括号里可以加参数 */ public void speak(){ System.out.println("我叫"+name+" 我今年"+age); } public static void main(String[] args) { // 定义一个Person类的对象zhangsan Person zhangsan; // 实例化对象 zhangsan=new Person(); // 给对象的name属性赋值 zhangsan.name="张三"; // 给对象的age属性赋值 zhangsan.age=23; zhangsan.speak(); // 调用对象的方法 } }
内存分析
方法是对象的一部分,也称为行为。
public class Person { int speak(String name,int age,String ...hobbies){ System.out.println("我叫"+name+",我今年"+age+"岁了"); for(String hobby:hobbies){ System.out.println(hobby+" "); } // 获取爱好的长度 int totalHobbies=hobbies.length; return totalHobbies; } public static void main(String[] args) { Person person=new Person(); int n=person.speak("张三",23,"游泳","唱歌"); System.out.println("有"+n+"个爱好"); } }
方法的值传递:
值传递 在方法里改变变量的值 作用范围仅仅是方法里 对外面不影响;
引用传递,传递的是地址,对象里的属性在方法里值修改,对外面有影响,我们通过对象.属性可以获取到最新的数据;
class SanWei{ int b; // 胸围 int w; // 腰围 int h; // 腿围 } public class Person { void speak(int age,SanWei sanWei){ System.out.println("我今年"+age+"岁了,我的三围是:"+sanWei.b+","+sanWei.w+","+sanWei.h); age=24; // 作用范围是方法里 sanWei.b=80; // 胸围改成80 } public static void main(String[] args) { Person xiaoli=new Person(); int age=23; SanWei sanWei=new SanWei(); sanWei.b=90; sanWei.w=60; sanWei.h=90; // age传递的是值 ,sanWei是对象,传递的是引用(地址,c里叫指针) xiaoli.speak(age,sanWei); System.out.println(age); System.out.println(sanWei.b); } }
内存示意图
方法的重载:类里面有两个或者多个重名的方法,但是方法的参数个数、类型、顺序至少有一个不一样,这时候局构成方法重载;
public class Demo01 { int add(int a,int b){ System.out.println("方法一"); return a+b; } /** * 方法的重载,参数个数不一样 * @param a * @param b * @param c * @return */ int add(int a,int b,int c){ System.out.println("方法二"); return a+b+c; } /** * 方法的重载,参数的类型不一样 * @param a * @param b * @return */ int add(int a,String b){ System.out.println("方法三"); return a+Integer.parseInt(b); } /** * 参数类型个数一样,返回值类型不一样 不算重载,直接会报错,说方法重名 * @param args */ /*long add(int a,int b){ return a+b; }*/ public static void main(String[] args) { Demo01 demo=new Demo01(); System.out.println(demo.add(1, 2)); System.out.println(demo.add(1, 2,3)); System.out.println(demo.add(1, "3")); } }
注意:假如参数个数和类型一样,返回值不一样,不能算重载,直接是编译出错,编译器认为是方法重复了。
java里方法分为 static静态方法和普通方法
所谓静态方法 是加了static修饰词的方法,我们使用的时候 一般用类名.方法 方式调用;
当然也可以用对象.方法 调用; 一般java里的工具类里的工具方法 用static修饰,作为静态方法;
递归,就是程序调用自身,我们讲的是方法递归调用,也就是在方法里自己调用自己;
//求阶乘 1*2*3*...*(n-1)*n public class Demo { /** * 递归方式 * @param n * @return */ static long diGui(int n){ if(n==1){ return 1; } return diGui(n-1)*n; } public static void main(String[] args) { System.out.println(Demo03.diGui(5)); } }
/*用递归实现斐波那契数列 1、1、2、3、5、8、13、21、... F(1)=1, f(2)=1 F(N)=F(N-1)+F(N-2) */ public class Demo{ long fun(int n){ if(n==1 || n==2){ return 1; } return fun(n-1)+fun(n-2); } public static void main(String[] args) { System.out.println(new Test().fun(7)); } }
构造方法
概念:构造方法是一个特殊的方法,这个特殊方法用于创建实例时执行初始化操作;
特点 1,没有返回值类型,区别于其他一般方法;
2,方法名和类名一样;
注意点:
1,假如没有构造方法,系统会自动生成一个默认的无参构造方法;
2,假如有构造方法,系统不会自动生成构造方法;
/** * 定义人类 * @author user * */ public class People { // 定义属性 private String name; // 实例化对象时,默认值是null private int age; // 实例化对象时,默认值是0 /** * 默认构造方法 */ People(){ System.out.println("默认构造方法!"); } /** * 有参数的构造方法 * @param name2 * @param age2 */ People(String name2,int age2){ System.out.println("调用的是有参数的构造方法"); name=name2; age=age2; } public void say(){ System.out.println("我叫:"+name+",我今年:"+age); } public static void main(String[] args) { // People people=new People(); People people=new People("张三",20); people.say(); } }
this,关键字,表示当前对象
1,使用this调用本类中的属性;
2,使用this调用构造方法;
/** * 定义人类 * @author user * */ public class People { // 定义属性 private String name; // 实例化对象时,默认值是null private int age; // 实例化对象时,默认值是0 /** * 默认构造方法 */ People(){ System.out.println("默认构造方法!"); } /** * 有参数的构造方法 * @param name * @param age */ People(String name,int age){ this(); // 调用无参数的构造方法 System.out.println("调用的是有参数的构造方法"); this.name=name; this.age=age; } public void say(){ System.out.println("我叫:"+name+",我今年:"+age); } public static void main(String[] args) { // People people=new People(); People people=new People("张三",20); people.say(); } }
运行输出:
默认构造方法!
调用的是有参数的构造方法
我叫:张三,我今年:20
访问控制权限:private(私有), package(包访问权限),protected(子类访问权限),public(公共访问权限)
代码块主要就是通过{}花括号 括起来的代码;
主要分为 普通代码块 构造块 静态代码块三类。
普通代码块:仅仅是花括号括起来的代码块;
构造块作用就是扩展构造器功能 每次实例化对象都会执行构造块里的内容,每次调用构造方法 都会先执行 构造块;
静态代码块:{}花括号前加static修饰词 在类加载的时候执行 而且只执行一次;
实例化String对象
public static void main(String[] args) { // 实例化String的方式一 String name1="张三"; System.out.println("name1="+name1); // 实例化String的方式二 String name2=new String("李四"); System.out.println("name2="+name2); }
“==”VS“equals方法”
“==” 比较的是引用(是否指向同一个内存块) “equals”比较的是具体内容;
public static void main(String[] args) { String name1="张三"; // 直接赋值方式 String name2=new String("张三"); // new方式 String name3=name2; // 传递引用 // ==比较的是引用 System.out.println("name1==name2:"+(name1==name2)); System.out.println("name1==name3:"+(name1==name3)); System.out.println("name2==name3:"+(name2==name3)); // equals比较的是具体内容 System.out.println("name1.equals(name2):"+(name1.equals(name2))); System.out.println("name1.equals(name3:"+(name1.equals(name3))); System.out.println("name2.equals(name3):"+(name2.equals(name3))); }
运行输出:
name1==name2:false
name1==name3:false
name2==name3:true
name1.equals(name2):true
name1.equals(name3:true
name2.equals(name3):true
String两种实例化方式的区别:
直接赋值方式,创建的对象存放到字符串对象池里,假如存在的,就不会再创建;
new对象方式,每次都创建一个新的对象;
public static void main(String[] args) { String name1="张三"; String name2="张三"; String name3=new String("张三"); String name4=new String("张三"); System.out.println("name1==name2:"+(name1==name2)); System.out.println("name1==name3:"+(name1==name3)); System.out.println("name3==name4:"+(name3==name4)); }
运行输出:
name1==name2:true
name1==name3:false
name3==name4:false
字符串的内容不可变性
字符串的特性:不能改变字符串的内容;
要想改变,只能通过指向一个新的内存地址;
public static void main(String[] args) { String name="张"; name+="三"; System.out.println(name); }
String类的常用方法:
1、char chartAt(int index) 返回指定索引处的char值,这里的index 是从0开始的
public static void main(String[] args) { String name="张三"; char ming=name.charAt(1); System.out.println(ming); String str="我是中国人"; for(int i=0;i<str.length();i++){ System.out.println(str.charAt(i)); } }
运行输出:
三
我
是
中
国
人
2、int length() 返回字符串的长度
3、int indexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引。
public static void main(String[] args) { // indexOf方法使用实例 String str="abcdefghijdklmoqprstuds"; System.out.println("d在字符串str中第一次出现的索引位置:"+str.indexOf(‘d‘)); System.out.println("d在字符串str中第一次出现的索引位置,从索引4位置开始:"+str.indexOf(‘d‘,4)); }
4、String substring(int beginIndex) 返回一个新的字符串,它是此字符串的一个子字符串。
public static void main(String[] args) { // substring方式读取 String str="不开心每一天"; String str2="不开心每一天,不可能"; String newStr=str.substring(1); System.out.println(newStr); String newStr2=str2.substring(1, 6); System.out.println(newStr2); }
5、public String toUpperCase() String 中的所有字符都转换为大写
public static void main(String[] args) { String str="I‘m a boy!"; String upStr=str.toUpperCase(); // 转成大写 System.out.println(upStr); String lowerStr=upStr.toLowerCase(); // 转成小写 System.out.println(lowerStr); }
//“ aB232 23 &*( s2 ”指定字符串,要求去掉前后空格,然后分别统计其中英文字符,空格,数字和其他字符的个数; public static void main(String[] args) { String str=" aB232 23 &*( s2 "; String newStr=str.trim(); // 去掉前后空格 System.out.println("str="+str); System.out.println("newStr="+newStr); int yingWen=0; // 英文个数 int kongGe=0; // 空格个数 int shuZi=0; // 数字个数 int qiTa=0; // 其他 for(int i=0;i<newStr.length();i++){ char c=newStr.charAt(i); // 判断英文字符 if((c>=‘a‘&&c<=‘z‘)||(c>=‘A‘&&c<=‘Z‘)){ yingWen++; System.out.println("英文字符:"+c); }else if(c>=‘0‘&&c<=‘9‘){ shuZi++; System.out.println("数字字符:"+c); }else if(c==‘ ‘){ kongGe++; System.out.println("空格字符:"+c); }else{ qiTa++; System.out.println("其他字符:"+c); } } System.out.println("英文个数:"+yingWen); System.out.println("空格个数:"+kongGe); System.out.println("数字个数:"+shuZi); System.out.println("其他个数:"+qiTa); }
//字符串反转,“abcdefg”,通过编程得到一个新的字符串“gfedcba” public static void main(String[] args) { String str="abcdefg"; String newStr=""; for(int i=str.length()-1;i>=0;i--){ newStr+=str.charAt(i); } System.out.println(newStr); }
//将字符串“1,3,5,7,9”,转换成数组,数组元素是整数元素1,3,5,7,9 ,
注意:这里需要使用int的包装类的parseInt方法 把字符串转成int类型; public static void main(String[] args) { String str="1,3,5,7,9"; int shuZi=0; for(int i=0;i<str.length();i++){ if(str.charAt(i)!=‘,‘){ shuZi++; } } int []arr=new int[shuZi]; int j=0; for(int i=0;i<str.length();i++){ if(str.charAt(i)!=‘,‘){ arr[j]=Integer.parseInt(str.charAt(i)+""); j++; } } for(int a:arr){ System.out.print(a+" "); } }
标签:读取 自动生成 加载 运行 ram zhang cte 静态代码块 string类
原文地址:https://www.cnblogs.com/CareyZhao/p/10319950.html