String类
String,StringBuffer,StringBuilder是一个final类,不可以再被继承,不可以再派生出子类
String不是一个关键字,是一个类
String的默认值是null
(1)String的定义声明
String name = “qin”
String name = new String(“qin”);
(2)String无法使用 ” ==“ 进行判断
(3)String使用直接赋值的方式后只要是以后声明的字符串内容相同,则不会再开辟新的内存空间
(4)String字符串一旦声明则不可改变
String str = “hello”;
str = str + “world”;//形成了一个新的内存块,新的内存块给了str,原有的内存不会变,而是指向了新的内存块
看到等于号内存一定变string内容不会变,改变的是推内存地址的指向。
看到 ”= “内存一定会变,
(5)字符串替换
String str = “qin”;
str = str.replace(“r”,“e”);//运行结果把r换成了e
str.replace(“r”,“e”);//运行结果不会变,此时是新成了一个内存块里面存着een,因为并没有将它赋值回去,所以并没有变
(6)String 切分
String str = “qin”;
String[] s = str.split("");
System.out.println(Arrays.toString(s));//运行结果就会变为一个数组[q,i,n]
String str = “qin”;
String[] s = str.split(“i”);//将字符串从i切分开
System.out.println(Arrays.toString(s));//得到结果为[q,n]
(7)求长
String str = “qin”;
System.out.println(str.length);
(8)定位
String str = “ren”;
知道角标找内容
System.out.println(str.charAt(3));
知道内容找角标
System.out.println(str.indexOf(“r”));
从后面往前找
System.out.println(str.lastIndexOf(“r”));
从指定位置开始查找指定的字符串位置
System.out.println(str.indexOf(“r”,0));
4、面向对象
面向对象五大原则
单一职责原则(SRP)
开放封闭原则(OCP)
里氏替换原则(LSP)
依赖倒置原则(DIP)
接口隔离原则(ISP)
##### 1、类
万事万物皆对象,先有对象后有类
对象——>抽象为——>类(封装、继承、多态)——>实例化——>对象
一个对象应该由自己的属性和方法组成
很多个对象中具有相同的属性和方法时,我们就可以将其抽象成类
抽象:提取多个对象相似的关键特征
属性的定义
String name ;
int age;
int height;
Person mate;
类:由属性和方法组成
用自然语言描述一个类时,这套描述的自然语言里
包含所有的名词为属性,可以直接给出一个明确的值
包含所有的动词为对象的行为,行为是一系列动作的集合
从对象创建类的过程是抽象的过程,由类申请内存把内容放到内存里的过程叫实例化,实例化完赋对象
看到new关键字出现就一定会创建一个对象,是一个新开辟的内存,新开辟的内存是对原有的内存的替换,其实真正切换的时候是通过赋值运算符实现的,不是new关键字
创建对象在场景类中
```Java
创建一个对象
A a = new A();
2、方法
方法():一系列动作的集合,参数为这个方法开始的条件,返回值为方法结束的条件,结果作为返回值存在,如果一个方法规定了一个返回值,就一定会返回一个值。
方法的定义:
访问控制 [static] 返回值类型 方法名(参数列表) {方法体}
参数列表(先写类型,再写形参名)
void:无返回值
对于参数的定义一定是类型加上形参名
动态方法(无static):必需有对象才能调用它
静态方法(有static):可以直接调用,不需要对象存在
当定义了一个带有返回值的方法时,必须使它返回一个值,应该加上 return 应该返回的值; 除void外定义为其他类型都必须返回相应的类型值,执行前需要参数传入
如定义为Byte时,返回一个Byte对象,如是byte时,返回一个byte值 ,
//当定义为Byte时返回一个Byte对象,当是byte时返回一个byte值
//除void外定义为其他类型都必须返回相应的类型值//
void hit(String type,int times) {
}
boolean hit1(String type,int times) {
if(2<3) {
return true;
}else {
return false;
}
for(int i = 0;i<10;i++) {
return true;
}
//当写了return后后面不能再加任何输出语句
return false; }
不定长参数:
//不定长参数 ...转为前面类型数组
//String[] arg 必须传一个值, ...可以不传值
//不定长参数一定放在参数列表中后面
//String... int... 等等
void foo(String... arg) { }
//方法的定义:
//返回值类型 方法名(参数列表) {方法体}
//参数列表(先写类型,再写形参名)
一个方法调用的简单例子
调用方法进行冒泡排序
import java.util.*;
public class Way{
public static void main(String[] args){
int[] arrays = {12,51,41,21,89,64};
int[] arrays1 = {12,99,21,33,89,4};
sort(arrays);//方法调用
sort(arrays1);
System.out.println(Arrays.toString(arrays));
System.out.println(Arrays.toString(arrays1));
}
//定义了一个返回值为int型数组的方法
public static int[] sort(int[] args){
for(int i = 0;i<args.length;i++){
for(int j = 0;j<args.length-i-1;j++){
if(args[j]<args[j+1]){
int temp = args[j];
args[j] = args[j+1];
args[j+1] = temp;
}
}
}
return args;//返回数组
}
}
构造方法:
名字与类名相同,无返回值,没有定义构造方法时Java会自动默认一个空的构造放法,创建对象时会自动调用构造方法,构造方法只能用于对象初始化,定义了构造方法后会覆盖之前的默认的空的构造方法,构造方法在普通方法前定义;
构造方法不带返回值,而普通方法是必须有返回值的,这就是区别他们的方法。即方法名可以和类同名,但是必须有返回值类型,而构造方法没有返回类型。
构造方法,只能是动态状态无static修饰。
this指当前的对象
当继承时父类没有无参构造方法时,子类必须重写有参数的构造方法
**构造方法不可以继承**
Human2(String name) {
//this指代当前的对象
this.name = name;
//特指某个对象的foo,这的this指的是Human2对象
this.foo(this);
}
模板类
public class Person{
//一个对象应该由自己的属性和方法组成
//很多个对象具有相同的属性和方法时,我们将其抽象为类
//属性的定义
String name;
int age;
int height;
Person mate;
//构造方法,名字与类名相同,下方是系统默认的空的构造方法
Person(){
}
//自定义构造方法
Person(String n){
System.out.println("创建新对象");
name = n;
}
//有参无返回值
void eat(String foodType,int price){ //这的参数为形式参数
System.out.println(name + "吃饭");//成员变量可以在成员方法中直接引用
System.out.println(foodType+" "+price);
}
//无参有返回值
int earnMoney(){
int a = 3;
int b = 5;
return a-b;
}
}
场景类
class Main{
public static void main(String[] args){
//创建一个Person类的对象p
Person p = new Person();
p.name = "王";
p.age = 23;
p.height = 188;
//再创建一个新的对象m,将mate传过来时,必须赋给的是一个对象
Person m = new Person();
m.name = "猫";
p.mate = m;
System.out.println(p.mate.name);
p.eat("面条",12);//实际参数
int money = p.earnMoney();
System.out.println(money);
}
}
当不给name属性和age属性赋值时,成员变量不赋初值可以使用;
class Main{
public static void main(String[] args){
//创建一个Person类的对象p
Person p = new Person();
p.height = 188;
p.eat("面条",12);//实际参数,此时打印结果为NULL吃饭,String默认结果为NULL
System.out.println(p.age);//此时返回int默认结果0
}
成员变量在方法外,类内定义,成员变量不赋初值可以使用;基础数据的成员变量都是有默认值的,对象数据类型的初始值时null,成员变量有效范畴在方法外类里任何位置,但是一般在类一进来就开始定义,在static代码块下。
public calss Human{
成员变量
int eyes;
String name;//对象数据类型初始值默认为null
public static void amin(String[] args) {
}
}
基础数据类型传值和引用数据类型传值
在方法中定义的非全局基本数据类型变量,调用方法时作为参数是按数值传递的
引用数据类型变量,调用方法时作为参数是按引用传递的,引用类型参数的传值:当参数是引用类型时(数组、对象、接口)
作业:三十个类,有构造方法,有属性
Java有5种方式来创建对象:
- 使用 new 关键字(最常用): ObjectName obj = new ObjectName();
- 使用反射的Class类的newInstance()方法: ObjectName obj = ObjectName.class.newInstance();
- 使用反射的Constructor类的newInstance()方法: ObjectName obj = ObjectName.class.getConstructor.newInstance();
- 使用对象克隆clone()方法: ObjectName obj = obj.clone();
- 使用反序列化(ObjectInputStream)的readObject()方法: try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(FILE_NAME))) { ObjectName obj = ois.readObject(); }