JAVA课堂笔记

java笔记

单词汇总
//double （64） 双精度小数
//int（32）整数
//char （） 字符型
//String （） 字符串用于储存一整串数字符
//double（） 双精度小数
//int （） 整数
//char （）字符型
float （） 单精度小数
byte （）字节型
short （）短整型
long （）长整型
Boolean（） 布尔类型
Static 静态的
Null 空的
Void 无
File 文件
Import 导入
Object 对象

Scanner 扫描仪
Package 包
Project 项目tybe 类型
Step 步骤
Error 错误
Height 高度
Weight 重量

Length 长度
Case 情况
Switch 开关
Default 默认
Break 跳出
Continue 继续
Exit 退出
Exception 异常
Consume 消耗
While 当…的时候
Do 做
If 如果
Else 否则
For 为
Out 外部
Index 索引
Match 数字
Equal 相等的
Return 返回
For 为
Array 数组
Sort 种类
Demo 演示
Sex 性别
Private 私有的
Protect 受保护的
Debug 调试
Bug 漏洞
Error 错误
Integer 整数
Set 设置
Value 值
Character 字符
Calculator 计算器

数据类型
Byte（字节型）用于存储单个字节
char(字符型)用于存储单个字符
int（整数）用于存储整数
double(双精度)用于存储小数
string(字符串)用于存储一整串数字符需要双引号
Boolean 布尔类型（判断真假）（true和false）
JAVA关键字
int public this finally boolean abstract
Continue float long

             整数类型（byte short int long）

基本数据类型 浮点（float double）

字符型（char）
布尔型（boolean）

引用数据类型 类（class）
接口（interface）
数组（array）

例如： public class 类名 {
public static void main(String[] args) {
数据类型 变量名 = 数值
输出语句=System.out.println(“ ”);
//数据类型 变量名 = 数值
//String 字符串用于储存一整串数字符串。
final 常量 通常大写
变量命名规范：简短且能清楚地表明变量的作用，通常第一个单词的首字母小写， 字母 $ 下划线1
其后单词的首字母大写。例如：myScore
publib static void main(String[]args){
System.out.println(“hello”);
例题：helloWord的输出
public class HelloWord{
public static void main(String[]args) {
System.out.println(“HelloJava”)；
}
}
二.去赋值运算符变量，数据类型和运算符
Public class HelloAccp3 {
Public static void main(String[] args) {
String title; 声明变量并赋值然后才能
System.out.println(title)；使用
} 表达式就是运算符（如加号，减号）与操作数（如b，3等）的组合
}
String title=”Java”//声明变量并赋值
String title; //声明变量
Title=”Java” //赋值
变量名不能以%开始
例题
1.某班的A学院Java成绩是80分，b班学员与a学员成绩相同，输出B学员成绩
int aScore=80
int bscore=；
ascore=bscore
system.out.println(bscore)；
bscore=ascore; //将右边的值给左边的变量
2.使用变量存储以下MPS信息，并打印输出
品牌（brand）:爱国者f928
重量（weight）：12.4
电池类型（type）：内置锂电池
价格（price）:499
第二章2.5算术运算符的应用
基本的算术运算

• • • / %
      例题
      某学院3门课程成绩如右表所示，编程实现：
      课程 分数
      STB 89
      Java 90
      SQL 60
      1.Java课和SQL课的分数之差
      2.3门课的平均分
      Public class Test{
      Public static void main(String[] args) {
      int java=90
      int sql=60
      int Stb=89
      int aa=java-sql
      int sum=java+sql+stb;
      int avg=sum/3;
      Systme.out.println(aa);
      Systme.out.println(avg);
      }
      }
      知识点：它可以是一个算术运算符也可以是一个连接符。
      1.当两个是非数值类型时 如果他们相加会被看做成一个（连接符）
      2.当一个是非数值类型另一个是数值类型时他们会被看成一个连接符
      3.当两个都是数值类型，如果他们相加就会被看成算数数当中的加号
      2.6认识%（取模）的作用
      例题1.根据天数（46）计算周数和剩余的天数
      int days=46
      int wek=days/7；
      System.out.println(‘’有’’+wek+”周”);
      int days1=days%7；
      System.out.println(“剩”+days1+”天”);
      2.7 数据的自动转换
      则1：如果一个操作数为double型，则整个表达式可提升为double型
      规则2：满足自动类型转换的条件
      （1）两种类型要兼容
      数值类型（整型和浮点型）互相兼容
      （2）目标类型大于源类型
      例如：double型大于int型 int a=10 System.out.println(a);
      左边目标类型 右边源类型 如果目标类型大于源类型 自动转换 目标类型小于元类型 强制类型。
      强制类型转换
      例题：去年Apple笔记本的市场份额是20，今年增长的市场份额是9.8，求今年所占市场份额？
      Public class Test{
      Public static void mian(string[] args){
      int year=20
      double f=9.8
      强制类型转换
      package First;
      public class AutoTypeChange {
      //自动类型转换
      //规则1：如果一个操作数为 double类型，则整个表达式可提升为double类型
      //规则2：满足自动类型转换的条件
      //条件 1.两种数据类型要兼容
      //条件2.目标类型大于源类型
      public static void main(String[] args) {
      double firstAvg = 81.5; //第一次考试的平均分
      double secondAvg; //第二次考试的平均分
      int rise = 2; //增长的分数
      secondAvg = firstAvg+rise; //自动类型转换
      System.out.println(“第二次考试的平均分是：”+secondAvg);
      }
      强制类型转换：
      题目：去年APPle笔记本所占的市场份额是20，今年增长市场份额是 9.8，求今年所占的份额？
      int before=20 //apple笔记本市场份额
      double rise=9.8；增长的份额
      int now=before+rise； //现在的份额
      //制类型转换 缩小转换
      // public static void main(String[] args) {
      // int defore = 20; //Apple笔记本市场份额
      // double rise = 9.8; //增张的份额
      // //计算新的市场份额(double类型变量强制转化成int类型变量)
      //double类型变量赋值给int类型变量
      // int now = defore+(int)rise; //现在的份额
      //语法（数据类型）表达式
      // System.out.println(“新的市场份额是”+now);
      // }
      }
      //对比
      //int a=1;
      //double b=a;
      //System.out.println(b);
      //
      //double a1=10.1;
      //int b1=(int)a;
      ////语法（数据类型）表达式
      //System.out.println(b1);
      2.8数据的输入
      利用扫描仪Scanner进行数据 的输入
      怎么使用扫描仪scanner
      （1）放在类声明之前，引入扫描仪
      （2）import java.util.Scanner;
      （3）声明一个新的扫描仪（即向内存声明一个空间）
      Scanner in；
      （4）赋值
      int=new scanner（system.in）；
      scanner input=new scanner（System.in）；
      （5）使用扫描仪
      整形输入：nextInt();来接收
      双精度小数输入：nextDouble();来接收
      字符串输入： next();来接收
      字符型输入：nextByte();来接收
      没有nextchar()来接收（）这个方法来接收单个字符的输入
      第三章：运算符和条件结构
      int A=45
      int b=78
      int t=a
      a=b
      b=t
      System.out.println(“a的值为”+A)
      System.out.println(“b值为”+b)
      }
      }
      If条件结构
      Import Java.util.Scanner；
      public class 51zxw{
      public static void mian(String[]){
      Scanner input=new Scanner(System.in)；
      System.outprint(“输入令狐冲的Java”)；
      Int score=input.nextlnt(); //令狐冲的Java成绩
      If(score>90){ //判断是否大于90分
      System,out.println(“师父说：不错，给你《独孤九剑》简谱)；
      }
      }
      运算符 表达式 说明
      && 条件成立1&&条件2 仅仅两个为真，结果为真
      || 条件1||条件2 只有两个条件有一个真，结果假
      ! ！条件 条件为真时，结果为假，反正则真
      转义字符
      \ddd 1-3位八进制数据所表示的字符，如\123
      \uxxxx 4位八进制数据所表示的字符，如\u0052
      \’ 单引号字符
      \ 反斜杠字符。
      \t 垂直制表符，将光标移动到下一个制表符的位置。
      \r 回车
      \n 换行
      \b 退格
      \f 换页
      随机数：
      int random=(int)(Math.random()10);
      1，数据类型
      char 字符型 char a=“男”;
      int 整形 int a=10;
      int b=input.nextInt()；
      double 双精度浮点型 double a=5.9
      double b=input.nextDouble()；
      String 字符串 string a=“襄阳”;
      String b=input.next();
      Scanner 扫描仪 scanner input=new scanner(System.in)；
      2，算数符
      1，赋值运算符。=最后运算，把右边的放入到左边去。
      2，算数运算符。±/%.
      3, 关系运算符。> < >= <= == ！=
      4,逻辑运算符。 &&：并且 | |：或者 ！：非，取反 ！>&&>||
      优先级：赋值运算符》算数运算符》关系运算符》逻辑运算符
      真&&真=真
      真&假=假
      假&&真=假
      假&&假=假
      真| | 真=真
      真| | 假=真
      假| |真=真
      假| |假=假
      ！真=假
      ！假=真
      3，语法结构
      条件结构：
      题目1，输入一个数字判断这个根据是大于等于零，还是小于零。
      如果（大于等于零） {
      输出：“大于等于零”
      }
      否则
      {
      输出：“小于零”
      }
      if（条件）{
      }else{
      }
      2.多重条件结构
      if-else if-else
      if（条件一）{
      //代码一
      }else if（条件二）{
      //代码二
      }else if（条件三）
      //代码三
      …
      else{
      //代码四
      }
      分支结构：switch（） case default
      switch（表达式或某值）{
      case 1：
      xxx
      break
      case 2:
      xxx
      break
      case3:
      Break
      If 后面分号（；）也是一个完整的表达式
      2.if(sex.equals(“y”)) 判断字符串是否一致
      Scanner input1=new Scanner(System.in);
      System.out.println(“请输入是否为会员：y为会员 N为普通会员”);
      Scanner input;
      String sex=input.next();
      System.out.println(“请输入您的金额”);
      double a=0.9; double b = 0.75;
      int money=input.nextInt();
      if(sex.equals(“y”)) {
      if(money>200) {
      int b1;
      System.out.println(“折扣价：”+(b1*money));
      }else {
      String g;
      System.out.println(“原价为”+g);
      比较switch和多重if选择结构
      相同点
      都是用来比较处理多分支条件的结构
      不同点
      switch多分支语句
      Switch（表达式）{
      Case 1:
      System.out.println(“1”)
      Case 2:
      System.out.println(“2”);
      Break:
      case 3:
      System.out.println(“3”);
      Break：（跳出）
      Default(默认）
      System.out.println(“就可以搬动桌子”);
      }
      比较switch和多重if选择结构
      相同点：都是用来处理多分支条件的结构
      不同：Switch选择结构只能处理等值条件判断的情况多重if选择结构没有if选择结构没有switch选择结构的限值，特别适合某个变量处于连续区间的情况。
      基本if选择结构：处理单一或组合条件的情况.
      If-else选择结构：处理简单的条件分支情况
      多重if选择结构：处理复杂的条件分支情况
      嵌套if选择结构：用于处理复杂的流程控制。

for(初始部分 ；条件判断；改变循环变量）{
③循环操作； 循环体被执行 }for 循环结构执行的顺序
1.执行初始化部分（int i=0）;
2.进行循环条件判断（i<100）；
根据循环条件判断结果，如果为true,则执行循环体，如果为false
3.e，则退出循环步骤（4）步骤（5）均不执行
执行迭代部分，改变循环变量值（i++）；
4.
5.以次重复步骤（2）步骤（4），直到退出for循环结构可见在for循环结构中，表达式1这个初始部分仅仅执行了一次先循环在判断For循环外层循环一次里面循环一遍三者的区别：循环次数确定的情况，通常用for循环次数不确定的情况，通常选用while和do while循环
Do while 先执行，在判断。
While循环While（循环条件）{
循环操作}
特点:先判断，在执行。
Break和continue的区别
Break语句用于终止某个循环，程序跳转到循环体外的下一个语句。
Continue语句用于跳出本次循环进入下一次循环语句。
运算符赋值运算符:以符号=表示，它是一个二元运算符，作用是将右边的数值赋值给左边。
算数运算符
加 减 乘 除 取余数 %

左边是否大于右边
<右边是否小于右边
==比较是否等于右
=左方是大于等于右边
<=左方是否小于右方
在逻辑运算符中，除了”!”是一元运算符外，其余都是二元运算符
逻辑运输符。
与或非
与 &和&&的区别：两个是短路，一个是非短路
&&:当一个条件为false时，不走第二个条件接返回
&：不论第一个条件为true还是为false都会走第二个条件
或|| |:||代表着只有一个是对的，那就是对的
运算符的优先级
算术运算符>比较运算符>逻辑运算符
最高优先：及小括号。
最低优先：即赋值运算符
当运算符比较多的时候，无法确定运算符执行序列是，可以使用小括号
自增自减
自增自减运算符是单目运算符，可以放在操作元之前，也可以放在操作元之后，操作元必须是一个整数型或者浮点型，自增自减的作用是使量加1减1，放在操作元前的为自增，自增会先将变量加1（减一，然后使用变量参与表达式的运算，放在操作云后面的自增自减运算符会使该变量的表达式的运算然后将它加一）（减1）
++a(–a)
a++(a–

数组基本要素
标识符： 数组的名称，用于区分不同的数组
数组元素：向数组中存放的数组
元素下标：对数组元素进行编号，从0开始，数组中的每个元素都可以通过下标来访问。
元素类型：数组元素的数据类型。
数组长度固定不变，避免数组越界。
数组中的元素必须属于相同数据类型。
一，使用数组的四步走
1：声明数组
2：分配空间

3：赋值

4：处理数据
赋值
数组名[下标值]
Scores[0]=89;
Scores[1]=60
求最大值
Max=scores[0];
if(a[1])>max
Max=score[1];
在循环中，循环变量i从0开始递增直到数组的最大长度scores.length.因此，每次循环i+1,实现数组的每个元素的累加
2.数组的升序和排序
使用java.Util.Arrays类
java.util包提供了许多工具类
Arrays类提供操作数组的方法
如:排序和查询。
Arrys类的sort()方法，对数组进行升序排序。
Arrys.sort(数组名);
二维数组
数据类型 [][] 数组名；或者<数组类型>数组名[][]

是一个变量，存储相同数据类型的一组数据
在内存空间划出一组连续的空间
标识符：数组的名称，用于存储同的数组
数组元素：存储相同的数组
元素下标：对数组元素排号
元素类型：数组元素的类型

1：声明数组
2：分配空间
3：赋值
4：处理赋值
src: 源数组
srcPos: 从源数组复制数据的起始位置
dest: 目标数组
destPos: 复制到目标数组的起始位置
length: 复制的长度

冒泡排序
每次比较相邻两数
小的交换到最前面
每轮结束后最大的数交换到最后

数组
arrays类的各种方法
Boolean equals(array1.array2)：
比较array1和array2两个数组是否相等
Sort(array) 对数组array的元素进行升序排序
String toString(array)： 将一个数组array转换成一个字串。
void fill(array.val) ：把数组array所以元素赋值为val。
Copyof（array.length）：把数组array复制成一个长度为length的新数组，返回类型与复制的数组一致
Int binarySearch(array.val)：查询元素val在数组array中的下标（要求数组中元素已经按升序排列）
数组冒泡排序：每次比较相邻两数没轮结束后最大的数交互到最后。

封装
对象同时具有属性和方法两项特性
封装的概念对象的属性和方法通常被封装在一起、共同体现事物的特性，二者相辅相成，不能分割。
封装的概念
将类的某些信息隐藏在类内部，不允许外部直接访问而是通过该类提供的方法来实现对隐藏信息的操作和访问
封装的思想
将类的属性和行为封装起来，其载体就是类类通常对“隐藏”其实现细节这就是封装的思想。
封装的好处：隐藏类的实现细；让使用者只能通过程序规定的方法来访问数据；可以方便的加入控制语句，限制不合理操作
Public + private -
类是模子，定义对象将会拥有的特征（属性）和行为（方法）
面向对象的优点
1.与人类的思维习惯一致
2.信息隐藏。提高程序的可重用性
3.方便修改实现

属性: 对象具有的各种特征
每个对象的每个属性都拥有特定值
对象执行的操作
对象：用来描述客观事物的一个实体，由一组属性和方法构成
类和对象的关系
类是抽象的概念，仅仅是模板
比如说：“人”
对象是一个你能够看得到、摸得着的具体实体。
中的下标（要求数组中元素已经按升序排序 ）
使用对象的步骤
创建对象
类名 对象名=new 类（）;
语法 School center=new School();
引用对象成员：使用“.”进行以下操作
语法 引用类的属性：对象名.属性
引用类的方法：对象名.方法（）
center.name=“北京中心”；//给name属性赋值
center.showCenter（）； //调用showCenter（）方法
成员变量和局部变量的区别
作用域不同
局部变量的作用域仅限于定义它的方法
成员变量的作用域在整个类内部都是可见的
初始值不同
java会给成员变量一个初始值
java不会给局部变量赋予初始值
注意：在同一个方法中，不允许有同名局部变量
在不同的方法中，可以有同名局部变量
在同一个类中，成员变量和局部变量同名时，局部变量具有更高的优先级
面向对象的思想
类的方法实现某个特定的功能，其他类不需要知道它如何实现，调用方法就可以了，不用重复写代码

JAVA数据类型的默认值
类型 默认值
int 0
Double 0.0
Char ‘\u0000’
Boolean false
String null

如何定义类的方法类的方法定义类的某种行为（或行为）

定义类的方法Public 返回值类型 方法名（） {// 方法的主体}

定义参数的方法<访问修饰符>返回类型<方法名>（<形式参数列表>） {
// 方法的主体}
Public class studentsBiz {String[] names=new string[30];
Public void addname(String name) {
// 增加学生姓名}
Public void shownames() {
//显示全部学生姓名}
}
调用带参数的方法对象名。方法名（参数1.参数2…参数n）

在不同类型中的列表顺序中不可互换。对象是用来描述客观事物的一个实体类定义了对象将会拥有的特征（属性）和行为（方法）
类是对象的类型，对象是类的实例
使用类的步骤
1.定义类：使用关键字class
2. 创建类的对象：使用关键字new
3.使用类的属性和方法：使用“.”操作符

标签 含义 标签 含义
@author 作者名 @version 版本
@paramater 参数及其意义 @since 最早使用该方法/类/接口的JDK版本
@return 返回值 @thrpws 异常类及抛出条件

类中定义的是形参 调用的叫实参 名字随意

方法的定义：
类的无参和带参
1.方法名称
2.方法返回值数据类型
3.方法的主体如果方法具有返回值，方法中必须使用关键字return返回该值，返回值的类型为该返回值的类型如果方法没有返回值，返回值类型为void
本类中的方法可以直接调用

构造方法的重载
Public penguin(){
Name=”qq”;
Sex=”Q仔” 方法名相同
参数数据类型或参数个数不同
与返回值，访问修饰符无关
}
This关键字是对一对象的默认引用，这里用以区分同名成员变量
1.使用this调用成员变量，解决成员变量和局部变量的同名冲突
2.使用this调用重载的构造方法，只能在在构造方法中使用，必须是构造方法的第一句。
注 因为this在对象内部指代自身的引用，所以this只能调用实例变量，实例方法和构造方法。
This不能调用类变量和类方法也不能调用局部变量。-
1.构造函数的作用
1） 创建对象。任何一个对象创建时，都需要初始化才能使用，所以任何类想要创建实例对象就必须具有构造函数。

  　2）  对象初始化。构造函数可以对对象进行初始化，并且是给与之格式（参数列表）相符合的对象初始化，是具有一定针对性的初始化函数。   2.构造函数与普通函数的区别

1） 格式不同：
　　　　　　构造函数不存在返回类型，函数与所在类的类一致；
　　　　　　普通函数有返回类型，函数名可以根据需求进行命名。
　　　　2）调用时期不同
构造函数在类的对象创建时就运行；　普通函数在对象调用时才会执行。
　　　　3）执行次数不同
　　一个对象创建后，其构造函数只执行一次，就是创建时执行；
一个对象创建后，其普通函数可以执行多次，取决于对象的调用次数。
Static和非static修饰的区别
Static，非static修饰 非static，private修饰
属性 类属性，类变量 实例属性，实例变量
方法 类方法 实例方法
调用方式 类名.属性
类名.方法（）
对象.属性
对象.方法（） 对象.属性
对象.方法（）

归属 类 单个对象
用static final修饰的变量的固定值不能改变。
在实例方法里不可以定义static属性。

Private void sename(String name) {
This.name=name;
This关键字
This引用的本类的一个对象。在局部变量或方法参数覆盖了成员变量时，如上面代码的情况，就要添加this关键字明确引用的是类成员还是局部变量或方法参数。其实this除了可以调用成员变量或成员方法外，还可以作为方法的返回值。

String 类
Equals（）方法的比较原理
√ √ √ √
字符串1

字符串 2
√ √ √ √

Equals（）检查组成字符串内容的字符是否完全一致
“==”和equal()有什么区别
◎ ==，判断两个字符串在内存中的地址
即判断是否是在同一个字符串对象。
字符串比较的其他方法
使用equaISIgnoreCase()方法 忽略大小写
toLowerCase()方法为小写
toupperCase()方法为大写

字符串连接
方法1： 使用“+”

方法名 说明
Public int indexof(int ch) 搜素第一个出现的字符ch(或字符串value).如果没有找到返回1
Public int indexof(String value)
Public int lastindex(int ch) 搜素最后一个出现的字符ch(或字符串value),如果没有找到，返回1
Public int lastindex(String value)
Public String substring(int index) 提取从位置索引开始的字符串部分
Public String substring(int beginindex,int endindex) 提取beginindex和endindex之间的字符串部分
Public string trim() 返回一个前后不含任何空格的调用字符串的副本
Split 用于分割字符串为字符串 例：
Replace()方法将会将所有olderchar全部替换成newchar. String str=”java project”; // 转换strung
String ne=str.replace(“j,””J”); // 追加字符串
要替换的olderchar的大小写要与原字符串的大小写保持一致，否则不能替换 // 插入字符串
Stringbuffer对于字符串频繁修改（如字符串连接）时，使用stringbuffer类可以大大提高程序执行效率 Stringbuffer声明
Stringbuffer strb=new stringbuffer();
Stringbuffer strb=new stringbuffer();
Stringbuffer使用
Sb.tostring();
Sb.append(“”)；Sb.insert(1,“”);

String是不可改变对象
经常改变内容的字符串最好不要使用string
Stringbuffer是客改变的字符串
字符串经常改变的情况可使用stringbuffer，更高效
JDK1.5后提供了stringbuffer，等级stringbuffer
0 change to construction
改变构造。
Format(String format,object…args) 该方法使用指定的格式字符串和参数返回一个格式化字符串，格式化后的新字符串使用本地默认的语言环境。
compareToIgnoreCase()比较字符串大小
Startswith()方法
Endswith（string suffix） 1,该方用以判断当前字符串的前缀是否为参数指定的字符串
2.该方法用以判断当前字符串是否以给定的字符串结束
方法2：使用string类的concat()方法

对于开始位置beginindex java是基于字符串首字符为0来进行处理的，但是对于终止位置endindex, java是基于首字符为1来处理的。

代码实现：
package character;

public cl9ass TestString {

public static void main(String[] args) {

    String name ="盖伦";
     
    System.out.println(name.length());
     
    String unknowHero = "";
     
    //可以有长度为0的字符串,即空字符串
    System.out.println(unknowHero.length());
      
}

}
字符串格式化
package character;

public class TestString {

public static void main(String[] args) {

    String name ="盖伦";
    int kill = 8;
    String title="超神";
      
    //直接使用+进行字符串连接，编码感觉会比较繁琐，并且维护性差,易读性差
    String sentence = name+ " 在进行了连续 " + kill + " 次击杀后，获得了 " + title +" 的称号";
      
    System.out.println(sentence);
     
    //格式化字符串
    //%s表示字符串，%d表示数字,%n表示换行
    String sentenceFormat ="%s 在进行了连续 %d 次击杀后，获得了 %s 的称号%n";
     
    String sentence2 = String.format(sentenceFormat, name,kill,title);
     
    System.out.println(sentence2);
     
}

}
获取字符
package character;

public class TestString {

public static void main(String[] args) {

	String sentence = "盖伦,在进行了连续8次击杀后,获得了 超神 的称号";
	
	char c = sentence.charAt(0);
	
	System.out.println(c);
      
}

}
获得对应字符数组
package character;

public class TestString {

public static void main(String[] args) {

String sentence = “盖伦,在进行了连续8次击杀后,获得了超神 的称号”;

char[] cs = sentence.toCharArray(); //
	
System.out.println(sentence.length()== cs.length);
	
}

}
去掉收尾空格

String sentence = "  盖伦,在进行了连续8次击杀后,获得了 超神 的称号 ";

System.out.println(sentence);
//去掉首尾空格
System.out.println(sentence.trim());
}
}

大小写

String sentence = "Garen";
	
//全部变成小写
System.out.println(sentence.toLowerCase());
//全部变成大写
System.out.println(sentence.toUpperCase());
	
}

}

定位
String sentence = “盖伦,在进行了连续8次击杀后,获得了超神 的称号”;

System.out.println(sentence.indexOf(‘8’)); //字符第一次出现的位置

    System.out.println(sentence.indexOf("超神")); //字符串第一次出现的位置
     
    System.out.println(sentence.lastIndexOf("了")); //字符串最后出现的位置
     
    System.out.println(sentence.indexOf(',',5)); //从位置5开始，出现的第一次,的位置
     System.out.println(sentence.contains("击杀")); //是否包含字符串"击杀"
     
}

}
替换

String sentence = “盖伦,在进行了连续8次击杀后,获得了超神 的称号”;

String temp = sentence.replaceAll(“击杀”, “被击杀”); //替换所有的

    temp = temp.replaceAll("超神", "超鬼");
     
    System.out.println(temp);
     
    temp = sentence.replaceFirst(",","");//只替换第一个
     
    System.out.println(temp);
     
}

}
包装类
包装类把基本类型数据转换成为对象
每个基本类型在java。Lang包中都有一个相应的包装类
包装类的作用
提供了一系列实用方法
集合不允许存放基本数据类型数据，存放数字时，要用包装类类型。

205

所以包装类都可以将与之对应的基本数据类型作为参数，来构造他们的实例
包装类的常用方法
Public type（type value）
如：integer i=new integer(1);
除character类外，其他类包装类可将一个字符串作为参数构造他们的实例。
Public Type（Stirng value）
如： integer i=new integer(“123”)
1：Boolean类构造方法参数数为String类型时，若该字符串内容为true（不考虑大小写）则该Boolean对象表示true，否则表示false
2.当包装类构造方法参数为String类型时，字符串不能为null,且该字符必须解析为相应的基本数据类型的数据，否则编译不能通过，运行时numberformatexception异常
所以包装类都有如下方法
Public static type valueof（tybe value）
如：integer intvalue=integer.valueof(21);
除character类外，其他包装类都有如下方法
Public static tybe valueof(Stirng s)
如:integer intvalue=integer.valueof(“21”);
Double doublevalue=double.Valueof(“abc”);
Xxxvalue();包装类转换成基本类型
Integer integer;d=new integer(25);

总结
面向对象的思想开放程序的好处
找出名词确定类，属性
从现实世界抽象出类 找出动词确定方法
删除与业务无关的属性和方法

               方法名相同

方法的重载的规则 参数项不同
与访问修饰符和返回值无关

Static可以修饰属性，方法，静态块

实现封装的步骤 修改属性的可见性
创建公有的getter/setter方法
在getter/setter方法中加入属性控制语句

如何使用继承
Class pet{
//公有的属性和方法
编写子类，继承父类
Class Dog extends pet{ 只能继承一个父类
// 子类特有的属性和方法
Class penguin extends pet{
继承关键字 extends 对比c#用“：”
理解继承
子类访问父类成员 使用super关键字super代表父类对象
访问父类构造方法
Super(); 在子类构造方法中调用且必须是第一句
Super(name);
访问父类的属性
Super.name;
访问父类的方法
Super.print();

Supper关键字来访问父类的成员
Supper只能出现在子类的方法和构造方法中
Supper调用构造方法时，只能是第一句
Supper不能访问父类的private成员

子类可以继承父类的所以资源吗？
不能被继承的父类成员
1.Private成员
子类与父类不在同包，使用默认访问权限的成员
2.构造方法。

访问修饰符protected可以修饰属性和方法本类。同包，子类可以访问。
Private 成员变量和方法只能在其定义的类中别访问，具有类的可见性
Public 可以被同一个项目中的所有类访问，具有项目可见性，最大的访问权限
总结
访问修饰符 本类 同包 子类 其他
Private √
默（friendly） √ √
Protected √ √ √
Public √ √ √ √

多重继承关系的初始化顺序是怎样的：

构造方法也会被继承吗? 不能被继承，因此不能被重新
方法的重写规则
方法名相同
参数列表相同
返回值类型相同或者是其子类
访问权限不能严于父类
1.@Override（覆盖） 注解
实现方法重新
方法重写和方法重载
位置 方法名 参数表 返回值 访问修饰符
方法重写 子类 相同 相同 相同或是其子类 不能比父类更严格
方法重载 同类 相同 不相同 无关 无关

Object类是所以类的父类
Object类被子类经常重写的方法G
方法 说明
tostring() 返回当前对象本身的有管信息，按字符串对象返回
Equal() 比较两个对象是否是同一个对象，是则返回true
hashCode() 返回该对象的哈希代码值
getClass 获取当前对象所属的类的信息，返回class对象

Object类的equal()方法
比较两个对象是否同一个对象，如果是返回true
操作符==
简单数据类型，直接比较值。如 12
引用类型，比较两着是否为同一对象
（1）object类equal()方法与没区别
（2）当有特殊需求如认为属性相同即为同一对象时，需要重写equals()
（3）Java.lang.String重写了equals()方法，把equals()方法的判断变为了判断值。
Instanceof （实例运算符）

abstract抽象类（抽象）
abstract也可用于方法———抽象方法
抽象方法没有方法体
抽象方法必须在抽象类中
抽象方法必须在子类中被实现，除非子类是抽象类
区别1：
子类只能继承一个抽象类，不能继承多个
子类可以实现多个接口
区别2：
抽象类可以定义
public,protected,package,private
静态和非静态属性
final和非final属性
但是接口中声明的属性，只能是
public
静态
final的
即便没有显式的声明

注: 抽象类和接口都可以有实体方法。 接口中的实体方法，叫做默认方法
Final修饰符：
修饰的类，不能再被继承
修饰的方法，不能被子类重写
修饰的变量将变成常量，只能在初始化时进行赋值

1. List item