JAVA到入门到精通

利用多态可以使程序具有良好的扩展性，并可以对所有类对象进行通用的处理。

假如现在要编写一个绘制图形的方法draw（），如果传入正方形对象将绘制正方形，如果传入圆形对象就绘制圆形，这种场景可以使用重载来实现，定义如下：

public void draw(Square s){
//绘制正方形的方法
}
public void draw(Circular c){
//绘制圆形方法
}

对象类型的转换在java编程中经常遇到，主要包括向上转型和向下转型操作

1.向上转型

向上转型：将子类对象赋值给父类引用

(自动类型转换)

Animal  a=new Dog();
2.向下转型 

向下转型：将父类对象赋值给子类引用

（需要进行强制类型转换）

Dog a=(Dog) new Animal();

在Object类中，主要包括clone（），finalize（），equals（），toString()等方法，其中常用的两个方法为equals()和toString()方法。由于所有的类都是object类的子类，所以任何类都可以重写object类中的方法。

（1）getClass（）方法

getClass（）方法是object类定义的方法，它会返回对象执行的Class实例，然后使用该实例调用getName（）方法可以取得类的名称。语法如下：

getClass（）.getname（）；
 方法的重写

返回参数相同，方法名相同，传入参数相同，方法体不同
（2）tostring（）方法

tostring（）的功能是将一个对象返回为字符串形式，它会返回一个String实例，在实际的应用中通常重写tostring（）方法，为对象提供一个特定的输出的模式，当这个类转换为字符串或与字符串连接时，将自动调用用重写的tostring（）方法。

equals（）方法

在Java语言中，有两种比较对象的方式，分别为“==”运算符与equals（）方法，两者区别在于：“==”比较的是两个对象引用内存地址是否相等，而equals（）方法比较的是两个对象的实际内容，所以equals（）方法判断出了这两个对象实际上是同一个，而“==”运算符无法做出有效判断，如果两个对象类型的不同，那么equals（）方法就会认为两者都不同 。
 

Java语言每一个类只能继承一个父类。叫做单继承；
extends（继承），
父类的写法；
public class 父类类名 (){
}
子类的写法
public  class 子类类名 extends 父类类名；

所有类的构造方法第一行都有一个隐藏的“super();"作用是在执行该构造方法之前调用其父类构造方法

子类重写父类的方法：

返回参数相同方法名相同传入参数相同只有方法体不同

向上转型
clone=克隆；
equals=相同；
finalize=相等；
toSteing=

子类对象赋值给父类引用 

Animal a = newDog();

自动类型转换

向下转型
父类对象赋值给子类引用

 Dog a = new Animal( );

强制类型转换

对象名 instanceof 类名 作用：
判断对象是否属于该类或其子类
对象名  instanceof  接口名 
判断对象是否属于该接口的实现类

方法名相同 参数不同,返回值 方法名（参数数据类型....参数名称）

final变量：
final修饰变量----不可改变的量（常量）

final方法：
final修饰方法----不可被重写

final类：
final修饰类----不能被继承

抽象方法：
修饰符 abstract 返回参数 方法名（传入参数）;列：public abstract void methodName()

抽象类：

使用abtract而使用这个关键字定义的方法称为抽象方法。抽象方性没有方法体，这个方法本身没有任何意义，除非它被重写，而承载这个抽象方法的抽象类必须被继承

实际上抽象类除了被维承没有任何意义.定义抽象类的语法如下:

public abstract class Parent{  

                                                        //定义抽象方法

abstract void testAbstract();

}

有抽象方法的类一定是抽象类

修饰符 abstract class 类名{

}

Java中每个接口或类都来自不同的类包，无论是Java API中的类与接口还是自定义的类与接口，都需要隶属于某一个类包，这个类包包含了一些类和接口。

一个完整的类名需

要包名与类名的组合，每个类都隶属于一个类包， 只要保证同一类

包中的类不同名，就可以有效地避免同名类冲突的情况。

1.在src节点上右击，选择New/Package。

2.弹出New Java Package对话框，在name文本框中输入新建包名，然后点击Finish。

3.语法如下：

package 包名.metadata   是配置文件
.settings   设置文件
src         项目文件

(一)使用import关键字导入包
使用Java中的import关键字指定。例如，如果在程序中使用import关键字导入com.mr.Math类，在程序中使用Math类时就会自动选择com.mr.Math类。
import关键字语法
import com.mr.*;//导入com.mr包中的所有类

import com.mr Math//导入com.mr包中的Math类

在使用import关键字时，可以指定类的完整描述，如果为了使用包中更多的类，可以在使用import关键字指定时在包指定后加上*，这表示可以在程序中使用该包中的所有类。

（二）使用import导入静态成员
import static//静态成员

（一）成员内部类简介
在一个类中使用内部类，可以在内部类中直接存取其所在类的私有成员变量。

语法：

class OuterClass{             //外部类

        class innerClass{      //内部类

}

        }

知识点：

在成员内部类可以随意使用外部类的成员方法及成员变量，尽管这些类成员被修饰为private。


成员内部类不止可以在外部类中使用，在其他类中也可以使用。在其他类中创建内部类对象的语法非常特殊，语法如下：

外部类 outer=new 外部类（）;

外部类.内部类 inner=outer.new   内部类（）;

（二）使用this关键字获取内部类与外部类的引用
如果在外部类中定义的成员变量与内部类的成员变量名称相同，可以使用this关键字。

匿名类是只在创建对象时才会编写类体的一种写法。匿名类的特点是“现写现用”，其语法如下：

new 父类/父类接口（）{

        子类实现的内容

}

异常抛出后，如果不做任何处理，程序就会被终止。例如，将一个字符串转换为整型，可以通过Integer类的parseInt（）方法来实现。但如果该字符串不是数字形式，parseInt（）方法就会抛出异常， 程序将在出现异常的位置终止，不再执行下面的语句。

Java语言的异常捕获结构由try， catch 和finally 3部分组成。其中，try 语句块存放的是可能发生异常的Java语句；catch 语句块在try语句块之后，用来激发被捕获的异常: finally 语句块是异常处理结构的最后执行部分，无论try语句块中的代码如何退出，都将执行finally 语句块。

语法

try{

//程序代码块

}

catch（Exceptiontype1 e）{

//对Exceptiontype1的处理

catch（Exceptiontype e）{

//对Exceptiontype2的处理

}

...

finally{

//程序代码块

}
(1)try-catch语句块public class Baulk {//创建类Baulk
 
 public static void main(String[] args) {//主方法
  // TODO Auto-generated method stub
 try {
  int result = 3/0;//定义int型变量并赋值
  System.out.println("程序结束");
  System.out.println(result);//将变量输出
 }catch(ArithmeticException e) {
  System.out.println("出现算数异常");
 
 }
 }
 
}
//捕捉算数异常知识点：JAVA的异常处理是结构化的，不会因为一个异常影响整个程序的执行

注意：

有时为 了编程简单会忽略catch语句后的代码，这样try-catch语句就成了一种摆设，一旦程序在运行过程中出现了异常，就会导致最终运行结果与期望的不一致，而错误发生的原因很难查找因此要养成良好的编程习惯，最好在catch语句块中写入处理异常的代码。
（2）finaly语句块
知识点：
完整的异常处理语句一定要包含finally语句，无论程序中有无异常发生，并且无论之前的try-catch语句块是否顺利执行完毕，都会执行finally。
四种特殊情况下，finally块不会被执行
1.在finally语句块中发生了异常。
2.在前面的代码中使用了System.exit()退出程序。
3.程序所在的线程死亡。
4.关闭CPU。
代码：public class Baulk {//创建类Baulk
 
 public static void main(String[] args) {//主方法
  // TODO Auto-generated method stub
 try {
  int result = 3/1;//定义int型变量并赋值
  System.out.println(result);//将变量输出
 }catch(ArithmeticException e) {
  System.out.println("出现算数异常");
 }finally {
  System.out.println("程序结束");
 }
 }
 
}
//捕捉算数异常

使用throw关键字抛出异常
知识点：

throw关键字通常用于方法体中，并且抛出-个异常对象。程序在执行到throw语句时立即终止，它后面的语句都不执行。通过throw 抛出异常后，如果想在上一级代码中捕获并处理异常，则需要在抛出异常的方法中使用throws关键字在方法的声明中指明要抛出的异常:如果要捕捉throw抛出的异

常，则必须使用try-catch语句块

throw通常用来抛出用户自定义异常

知识点：throws关键字通常被应用在声明方法时，用来指定方法可能抛出的异常。多个异常可使用逗号分隔。

throw语句用于手动抛出一个异常。抛出异常后，程序会尝试查找匹配的catch块进行处理

在方法定义中使用throws语句，可以指定一种或多种异常类型，表示该方法可能抛出这些异常。

知识点

RuntimeException异常是程序运行过程中抛出的异常。Java类库的每个包中都定义了异常类，所有这些类都是Throwable类的子类。Throwable 类派生了两个子类，分别是Exception类和Error类。Error类及其子类用来描述Java运行系统中的内部错误以及资源耗尽的错误，这类错误比较严重。Excepio类称为非致命性类，可以通过捕捉处理使程序继续执行。Exception 类又根据错误发生的原因分为RuntimeException异常和除RuntimeException之外的异常。

字符串必须包含在一对双引号（“”）之内。例如：
"23.23"、"ABCDE"、"你好" String str;         String: 指定该变量为字符串变量类型；

str：任意有效的标识符，表示字符串变量的名称。

声明字符串变量s，代码如下：10.1.2 创建字符串10.1.2 创建字符串

String s;         

1. String(char a[])
2. String(char a[],int offset,int length)
3. String(char[] value)代码：

package tenbao;
public class Test {
 public static void main(String[] args) {
  //字符串变量的声明
  String s;
  
  //字符串变量初始化
//  s = "你好";
  s = new String("你好");
  System.out.println(s);
  
  //字符串变量初始化  传入字符类型数组
  char[] ch = {'g','o','o','d'};
  String st = new String(ch);
  System.out.println(ch);
  
  //字符串变量的初始化 传入字符串类型数组，初始索引号，个数
  char[] chr = {'s','t','u','d','e','n','t'};
  String str = new String(chr,2,4);
  System.out.println(str);
  
  //字符串相连接
  System.out.println(s + st);
  
  //字符串与其他相连接
  System.out.println(1.6 + str + 3);
 }
}
 

创建成功的字符串对象，其长度是固定的，内容不能被改变和编译。虽然使用“+”可以达到附加新字符或字符串的目的，但“+”会产生一个新的String实例，会在内存中创建新的字符串对象。如果重复地对字符串进行修改，将极大地增加系统开销。而JDK新增了可变的字符序列StringBuilder类，大大提高了频繁增加字符串的效率。

.日期格式化
例子：

Date data = new Date();      //创建Date对象date
String s = String.formate("%te",date);      //通过format()方法对date进行格式化
常用的日期格式化转换符如上表：2.时间格式化 

格式化时间的转换符如下表：

.格式化常见的日期时间组合

格式化日期与时间组合的转换符定义了各种日期时间组合的格式，其中最常见的如上表：

常规类型格式化可应用于任何参数类型，如下表：

子主题

使用 “+” 运算符可实现连接多个字符串的功能。



代码：package Join;
public class join {
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  String s1 = new String("春色绿千里");
  String s2 = new String("马蹄香万家");
  String s = s1 + "\n" + s2;
  System.out.println(s);
 }
}

代码：package Link;
public class Link {
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  int booktime = 4;
  float practice = 2.5f;
  //将字符串与整数类型、浮点类型相连、并将结果输出
  System.out.println("我每天花费" + booktime + "小时看书：" + practice + "小时上机练习");
  
 }
}

1. substring(int beginIndex)
该方法返回的是从指定的索引位置开始截取直到该字符串结尾的字串。语法如下：

str.substring(int beginIndex)

2. substring(int beginIndex,int endIndex)
该方法返回的是从字符串某一索引位置开始到某一位置结尾的字串。语法如下：

str.substring(int beginIndex，int engIndex)

trim() 方法返回字符串的副本，忽略前导空格和尾部空格。语法如下：

str.trim() 
例题10.6:

 
public class Blak {
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  String str = "  java  class   ";
  System.out.println("字符串原来的长度：" + str.length());
  //将 str 去掉前导和尾部的空格后的长度输出
  System.out.println("字符串现在的长度：" + str.trim().length());
 }
}
 

replace()方法可实现将指定的字符或字符串替换成新的字符或字符串。语法如下： 

str.replace(CharSequence target,CharSequence replacment)
例题10.7：

public class NewStr {
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  String str = "address";
  String newstr = str.replace("a","A");
  System.out.println(newstr);
 }
}
 

1.startsWith() 方法
该方法用于判断当前字符串对象的前缀是否为参数指定的字符串。语法如下：
startsWith(String prefix)
 2.endsWith() 方法
该方法用于判断当前字符串是否以给予的字符串结尾。语法如下：public class StartOrEnd {
 public static void main(String[] args) {
  //判断字符串开头
  String num1 = "22045612";
  boolean b1 = num1.startsWith("22");
  System.out.println(b1);
  
  //判断字符串结尾
  String num2 = "21304578";
  boolean b2 = num2.endsWith("78");
  System.out.println(b2);
 }
}

对字符串对象进行比较不能简单地使用比较运算符“==”

代码：

String tom =new String("I am a student");
 String jerry = new String("I am a student");
 boolean b = (tom == jerry);
布尔类型变量b的值位false,因为字符串是对象，tom、jerry是引用，如上图：
1.equals()方法

如果两个两个字符串具有相同的字符和长度，则使用equals()方法进行比较时，返回true。否则，返回false。

语法：str.equals(String otherstr)    //其中str、otherstr是要比较的两个字符串对象

2.equalslgnoreCase()方法

 使用equals()方法对字符串进行比较时是区分大小写的，而使用equalslgnoreCase()方法是在忽略了大小写的情况下比较两个字符串是否相等，返回结果仍为boolean类型

语法如下：equalslgnoreCase(String otherstr)      //其中str、otherstr是要比较的两个字符串对象

compareToO方法为按字典顺序比较两个字符串，该比较基于字符串中各个字符的Unicode值，按字典顺序将String对象表示的字符序列与参数字符串所表示的字符序列进行比较。
如果按字典顺序此String对象位于参数字符串之前，则比较结果为一个负整数；如果按字典顺序此String对象位于参数字符串之后，则比较结果为一个正整数；如果这两个字符串相等，则结果为0。

语法如下：str.compareTo(String otherstr)     //str、otherstr是要比较的两个字符串对象

 注意：compareTo()方法只有在equals(Object)方法返回true时才返回0

String 类的toLowerCase（)方法可将字符串中的所有大写字母改写为小写字母，而toUpperCase（)方法可将字符串中的所有小写字母改写为大写字母。

1.toLowerCase（)方法

该方法将字符串中的所有大写字母转换为小写

语法：str.toLowerCase（)       //str是要进行转换的字符串

2. toUpperCase（)方法

该方法将字符串中所有小写字母转换为大写

语法：str.toUpperCase（)       //str是要进行转换的字符串

1.split(String sign)
该方法可根据给定的分割符对字符串进行拆分

语法：str.split(String sign)   //sign为分割字符串的分割符，也可以使用正则表达式

2.split(String sign，int limit)

该方法可根据给定的分割符对字符串进行拆分，并限定拆分的次数

语法：str.split(String sign，int limit)

sign:分割字符串的分割符，也可以使用正则表达式

limit:限制的分割次数

Integer类在对象中包装了一个基本数据类型int的值，该类的对象包含一个int类型的字段。

常用方法如上表：

Double类和Float 类是对double、float 基本类型的封装,它们都是Number 类的子类,都是对浮点数进行操作，所以常用方法基本相同。
  Double 类在对象中包装一个基本类型为double 的值，每个Double类的对象都包含一个double 类型的字段。此外,该类还提供多个方法,可以将double 类型转换为String 类型,将String 类型转换为double类型，也提供了其他一些处理double类型时有用的常量和方法。

Boolean类将基本类型为boolean的值包装在一个对象中。一个Boolean 类型的对象只包含一个类型为boolean的字段。此外，此类还为boolean类型和String 类型的相互转换提供了许多方法，并提供了处理boolean 类型时非常有用的

Character类在对象中包装一个基本类型为char的值，该类提供了多种方法，以确定字符的类别(小写字母、数字等)，并可以很方便地将字符从大写转换成小写，反之亦然。Character 类提供了很多方法来完成对字符的操作

数值包装类的共有方法

在Java中，没有格式化的数据遵循以上原则：

1.如果数据绝对值大于0.001并且小于10000000，使以常规小数形式表示。

2.如果数据绝对值小于0.001或者大于10000000，是用科学计数法表示。DecimalFormat中的特殊字符及其所代表的含义如下：

Math类提供了众多数学函数方法，这些方法都被定义为static形式

形式调用如下：Math.数学方法

在Math类中，除了函数方法外还存在一些常用数学常量，如PI、E

形式调用如下：

Math.PI

 Math.E

 1.三角函数方法

Math类中包含的三角函数方法如下：

☑ _ public static double sin(double a);返回角的三角正弦。
☑ public static double cos(double a);返回角的三角余弦。
☑ public static double tan(double a);返回角的三角正切。
☑ public static double asin(double a):返回一个值的反正弦。
☑ public static double acos(double a):返回一个值的反余弦。
☑ public static double atan(double a):返回一个值的反正切。
☑ public static double toRadians(double angdeg):将角度转换为弧度。
☑ public static double toDegrees(double angrad):将弧度转换为角度。

Random对象创建一个随机数生成器语法如下：

Random r = new Random;

设置随机数生成器的种子 语法如下：

Random r = new Random(seedValue);

r: Random类对象。
seedValue：随机数生成器的种子。
在Random类中，提供了获取各种数据类型随机数的方法，下国之伙2今孙田计前
public int nextInt):返回一个随机整数。
public int nextInt(int n):返回大于等于0且小于n的随机
public long nextLong()：返回一个随机长整型值。
public boolean nextBoolean):返回一个随机布尔型值。
public float nextFloat()：返回一个随机单精度浮点型值。
public double nextDouble()：返回一个随机双精度浮点型应 
public double nextGaussian):返回一个概率密度为高斯少士8台晰明向叶进研

在Biglnteger类中封装了多种操作，除了基本的加、减、乘、除操作，还提供了绝对值、相反数、最大公约数以及判断是否为质数等操作。
使用BigInteger类，可以实例化一个BigInteger对象，并自动调用相应的构造函数。BigInteger类具有很多构造函数，但最直接的一种方式是参数以字符串形式代表要处理的数字。
例如，将2转换为BigInteger类型，可以使用以下语句进行初始化操作：
Biglnteger twolnstance =new Biglnteger("2");

注意:参数2的双引号不能省略，因为参数是以字符串的形式存在的。

       一旦创建了对象实例，就可以调用Biglnteger 类中的一些方法进行运算操作，包括基本的数学。算和位运算以及一些取相反数、取绝对值等操作。下面列举了Biglnteger类中常用的几种运算方法：public BigInteger add(BigInteger val)：做加法运算。
public BigInteger subtract(BigInteger val)：做减法运算。
public BigInteger multiply(BigInteger val)：做乘法运算。
public BigInteger divide(BigInteger val)：做除法运算。
public BigInteger remainder(BigInteger val)：做取余操作。
public BigIntegerl] divideAndRemainder(BigInteger val):用数组返回余数和商，结果数组中第一个值为商，第二个值为余数。
public BigInteger pow(int exponent):进行取参数的exponent次方操作。
public BigInteger negate()：取相反数。
public Biglnteger shiftLeft(int n)：将数字左移n位，如果n为负数，做右移操作。public BigInteger shiftRight(int n)：将数字右移n位，如果n为负数，做左移操作。public BigInteger and(BigInteger val)：做与操作。
public BigInteger or(BigInteger val)：做或操作。
public int compareTo(BigInteger val):做数字比较操作。
public boolean equals(Object x)：当参数x是BigInteger类型的数字并且数值与对象实例的数值相等时，返回true。
public BigInteger min(BigInteger val)：返回较小的数值。
public BigInteger max(Biglnteger val)：返回较大的数值。

在BigDecimal类，常用的两个构造方法如下：

子主题

使用Date类的第2种构造方法创建一个Date类的对象，代码如下：

long timeMillis = System.currentTimeMillis();    //当前系统时间所经历的毫秒数

Date date =new Date(timeMillis);

DateFormat 类是日期时间格式化子类的抽象类，可以按照指定的格式对日期或时间进行格式化。DateFormat类提供了很多类方法，以获得基于默认或给定语言环境和多种格式化风格的默认日期时间Formatter，格式化风格主要包括SHORT、MEDIUM、LONG和FULL4种：
SHORT：完全为数字，如12.13.52或3：30pm。
MEDIUM：较长，如Jan 12,1952。
LONG:更长，如January 12,1952或3：30：32pm。
FULL：完全指定，如Tuesday、April 12、1952AD或3：30:42pm PST。
  另外，使用DateFormat类还可以自定义日期时间的格式。要格式化一个当前语言环境下的日期，首先需要创建DateFormat类的一个对象，由于它是抽象类，因此可以使用其静态方法 getDateInstance()进行创建，语法如下：
DateFormat df =DateFormat.getDatelnstance();

Calendar 提供了一个类方法 getnstance()，以获得此类型的一个通用的对象。Calendar类的grtnstance()方法返回一个Calendar对象，其日历字段已由当前日期和时间初始化，其使用方法如下：

Calendar rightNow =Calendar.getlnstance();

说明：由于Calendar类是一个抽象类，不能用new创建实例对象，因此除了使用getInstance0方法创建其对象，如果需要创建其对象，必须使用其子类，如GregorianCalendar类。

本地命令指的是操作系统的命令。例如，在Linux系统下就表示shell命令，在Windows系统下就表示cmd命令。
Rutime类提供exec()方法让Java代码可以执行系统的命令，exec)方法有很多重载的形式，例如：

Process exec(String command)
Process exec(String， cmdarray)

command：要执行的系统命令，字符串类型。
cmdarray：要执行的命令和相应的命令参数，字符串数组类型。
其实这两个重载方式很类似，如执行“javac hellojava”这行命令，使用第一种重载方式的代码如下：Runtime.getRuntime().exec("javac hello.java");

使用第二种重载方式的代码如下：

String command，=("javac","hello.java"];
Runtime.getRuntime().exec(command);

exec)方法会返回一个 Process对象。Process类是Java中进程类，该类是抽象类，不能使用new关键字创建实例。Process类的常用方法如表11.22所示，开发可以使用getlnputStream)方法获取进程返回的信息。

代码：package a;
 
public class MemoryDemo {
 
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  Runtime r = Runtime.getRuntime();
  Integer ints[] =new Integer[10000];
  long before = r.freeMemory();
  System.out.println("赋值前空闲内存字结束："+before);
  for (int i = 0,length = ints.length;i< length;i++) {
   ints[i]=i;
  }
  long after = r.freeMemory();
  System.out.println("赋值后空闲内存字节数："+after);
  System.out.println("数组用掉的内存字节数："+(before-after));
 }
 
}注意：freeMemory()方法得到的剩余内存量是近似值。

1.不会自动换行的print()方法
printO方法的语法如下：

System.out.print("Hello!");

此方法输出“Hello”文字，输出完毕后，光标会停留在“Hello”文字末尾，不会自动换行。
2. 可以自动换行的 println()方法


printlnO方法在print后面加上了“1n”后缀(就是line的简写)，语法如下：

System.out.println(”书籍是人类进步的阶梯！”)；

此方法输出“书籍是人类进步的阶梯！”后会自动换行。光标停留在下一行的开头。

print()方法与println()方法输出的对比效果如上：综上所述，Java输出换行的方法有以下两种：

System.out.print("\n"); //利用换行符\n 实现奂行
System.out.println(); //空参数即可实现换行

误区警示：
使用这两个输出方法时还要注意以下两点：
(1)“System.out.println("n")；”会打印两个空行。
(2)“System.out.print);”无参数会报错。
原文出处链接及本声明。
原文链接：https://blog.csdn.net/zhengkaioo/article/details/130754107

代码：public class SystemTimeDemo {
 
 public static void main(String[] args) {
  // TODO Auto-generated method stub
 long start = System.currentTimeMillis();
 String str =null;
 for(int i=0;i<10000;i++) {
  str+=i;
  }
 long end = System.currentTimeMillis();
 System.out.println("循环用时："+(end-start)+"毫秒");
 }
 
}

Scanner类首先要引入该类，语法如下：

import java.util.Scanner;     //引入Scanner类

上表所示的常用的方法，通过这些方法可以获取控制台中输入的不同类型的值使用Scanner类扫描控制台的代码如下：

Scanner sc = new Scanner(System.in);

Eclipse由IBM公司投资4000万美元开发而成，它基于Java语言编写，是目前最流行的Java集成开发工具之一。Eclipse 所有代码都是开源的，可扩展，其后续开发由Eclipse联盟负责。

Eclipse为编程人员提供了-流的Java程序开发环境，它的平台体系结构是在插件概念的基础上构建的，插件是Eclipse平台最具特色的特征之一， 也是其区别于其他开发工具的

整数类型简称整型，用来存储整数数值，即没有小数部分的数值。可以是正数，也可以是负数。收型数据根据它所占内存大小的不同，可分为byte、 short、 int 和long 4种类型。它们具有不同的取值范围。

字符类型(char) 用于存储单个字符，占用16位(两个字节)的内存空间。在定义字符型变量要以单引号表示，如's表示 一个字符。 但是"s"则表示一个字符串，虽然只有一个字符，但由于使用引号，它仍然表示字符串，而不是字符。

子布尔类型又称逻辑类型，简称布尔型，通过关键字bolan来定义布尔类到数类型进行转换。布尔类型

和false 两个值，分别代表布尔逻辑中的“真”和“假”。布尔值不能与整数类型变量，布尔类型只有me通常被用在流程控制中，作为判断条件。定义布尔类型变量，

标识符：用来标识类名，变量名，方法名，数组名，文件名的有效字符序列。

关键词; 是Java语言中已经被赋予特定意义的一些单词，不可以把这些单词作为标识符来使用。主题

成员变量; 再类体中所声明的变量，成员变量在整个类中都有效

局部变量：在类的方法体中声明的变量（方法内部定义，“{“与”}”之间的代码中声明的变量）。局部变量只在当前代码块中有效，也就是只能在“{“与”}”之内使用。

常量： 在程序运行过程中一直不会改变的量称为常量，通常也被称为“final变量”常量在整个程序中只能被赋值一次。

由于变量被定义出来后只是暂存在内存中，等到程序执行到某一个点，该变量会被释放掉，也就是说变量有它的生命周期。因此，变量的有效范围是指程序代码能够访问该变量的区域，若超出该区域，则在编译时会出现错误。在程序中，一般会根据变量的“有效范围”将变量分为“成员变量”和“局部变量”。

将右方操作数所含的值赋给左方的操作数。

算术运算符主要有+，-，*，/，%。

符号在后，先使用，在运算。
符号在前，先运算，在使用。

属于二元运算符，用于程序中的变量之间，变量和自变量之前以及其他类型的信息之间额比较运算符的运行结果是boolean型
当运算符成立时，运算结果为true，否则为false。

&&，&两者都为真结果还是真
列：true&&false==false    true&&true==true
false&&false==false
||只有一种为真，结果就是真。
列：true||true==true，true||false==true
false||false==false
!:非真即假，非假即真。
列：！true==false，！false==true

按位与运算：&两者都为1，结果才是1。
按位或运算：||只有一者为1，结果才是1.
换位取反：0变1，1变0.
按位异或运算：两者相同，即为0，不同为1.
移位操作：<<:整体往左移，空位补0，溢出去掉。
>>:整体右移，正数补0，负数补1，溢出去掉。
>>>:整体右移，空位补0，溢出去掉。

条件式？值1：值2
                        条件为真选值1
                          条件为假选值2
                        列题：int a=6；
                            int b=a>3? 6:7;

增量和减量运算

算数运算

比较运算

逻辑运算

赋值运算

也叫隐式类型转换，指的是两种数据类型在转换的过程中不需要显式地进行声明。

要实现自动类型转换，必须同时满足两个条件，●第一是两种数据类型彼此兼容，

第二是目标类型的取值范围大于源类型的取值范围。byte b = 3;+

int x= b; /1 程序把byte类型的变量b转换成了int类型，无须特殊声明

➢强制类型转换也叫显式类型转换，指的是两种数据类型之间的转换需要进行显式地声明。

➢当两种类型彼此不兼容，或者目标类型取值范围小于源类型时，自动类型转换无法进行，这时就需要进行强制类型转换。

➢强制类型转换的格式如下所示:

目标类型变量= (目标类型) 值+

①①if条件语句、
if语句是指如果满足某种条件，就进行某种处理，其语法格式如下

所示:

if (条件语句){ ψ

代码块

}4

_上述语法格式中，判断条件是一个布尔值，当值为true时，才会执

行{}中的语句。

Java中的switch语句是一种用于根据一个表达式的值选择不同代码分支的流程控制语句。它通常用于取代一系列的if-else语句，以使代码更加简洁和易于阅读。
代码：

输入条件，进行判断，

pablic class Example10

public static void main(Stringl) arga) {
long week =6;

switch (week) {

case 1:

System.out.println("星期一 ");

break;

case 2:

System. out.println("星期二");

break;

case 3:

System. out.printin("星期三");

break;

case 4:

Ѕуѕtеm. оut . рrіntln ("星期四");

break;

case 5:

System. out.println("星期五");

break;

case 6:

System. out.println("星期六");

break;

case 7:

System. out.println("星期日");

break;

default:
System. out.println("输入错误");
break;

if...eIse语句
➢f..else语句是指如果满足某种条件，就进行某种处理，否则就进行

另一种处理，其语法格式如下所示:

if (判断条件) {v执行语句1

}else{

执行语句2

}

if..else if ..else语句用于对多个条件进行判断，进行多种不同的处理，其语法格式如下所示:

if (判断条件1) {

执行语句1

} else if (判断条件2) {执行语句2) {

执行语句2

}

........

else if (判断条件n) {执行语句n）{

        执行语句n

} else {

执行语句n+1

}

语句1
while(条件)
{语句2}
语句3
1->条件真->2->...条件真->2->条件假->3

         java中的while循环是一种重复执行代码块的语句，只要指定的条件为true，就会一直执行循环体中的语句。当条件变为false时，程序将跳出循环，并继续执行程序的下一条语句。

do{执行语句...}
while（循环语句）；
      是一种先执行循环体中的语句，然后再判断循环条件是否成立的循环结构。

do-while循环先执行一次循环体中的语句，然后再进行循环条件的判断。如果循环条件成立，就继续执行循环体中的语句，并继续进行循环条件的判断；如果循环条件不成立，则退出循环。需要注意的是，无论循环条件是否成立，do-while循环至少会执行一次循环体中的语句。

        与while循环相比，do-while循环的一个重要区别是循环条件的判断时机不同。在while循环中，循环条件是在循环体执行前判断的，因此如果循环条件一开始就不成立，while循环中的循环体不会执行；而在do-while循环中，循环条件是在循环体执行后判断的，因此即使循环条件一开始就不成立，do-while循环中的循环体也会执行一次。

ava的for循环语句是一种常用的循环结构，通常用于遍历集合或数组等数据结构。
跳转循环语句

在Java中，break语句是一种用于循环控制的关键字，通常用于在循环中提前终止循环的执行，即跳出循环体。当break语句被执行时，程序会立即跳出循环，继续执行后续的代码。

break语句通常与条件语句一起使用，例如在for循环或while循环中，如果满足某个条件就需要提前结束循环，可以使用break语句来实现。

Java中的continue语句用于在循环结构中提前结束当前循环的迭代，然后开始下一次迭代。具体来说，当continue语句被执行时，程序将跳过当前循环迭代中剩余的语句，然后进入下一次迭代，即从循环体的开始处重新执行。

continue语句通常用于需要跳过某些特定条件下的循环迭代的情况，

子主题

his关键字用于表示本类当前的对象，当前对象不是某个new出来的实体对象，而是当前正在编辑的类，this关键字只能在本类中使用。

public void setName（String name）{
this.name=name;
}

当子类重写父类的方法后，子类对象将无法访问父类被重写的方法，为了解决这个问题，在Java中专门提供了一个super关键字用于访问父类的成员。例如访问父类的成员变量、成员方法和构造方法。接下来分两种情况来学习一下super关键字的具体用法。

final关键字可用于修饰类、变量和方法，它有“无法改变”或者“最终的含义，因此被final修饰的类、变量和方法将具有以下特性:

1.final修饰的类不能被继承。
2.final修饰的方法不能被子类重写。

3.final修饰的变量(成员变量和局部变量)是常量，只能赋值一次

封装是面向对象编程的核心思想，将对象的属性和行为封装起来，其载体就是类，类通常对客户隐藏其实现细节，这就是封装思想。采用封装思想保证了类的内部数据结构的完整性，使用类的用户不能轻易地操作类的数据结构，只能执行类允许公开的数据，这样子避免了外部操作和内部数据影响，提高了程序的可维护性。

继承性主要描述的是类与类之间的关系，通过继承，可以在无需重新编写原有类的情况下，对原有类的功能进行扩展。继承不仅增强了代码的复用性、提高开发效率，还为程序的维护补充提供了便利。

多态性指是在程序中允许出现重名的现象，它指在一个类中定义的属性和方法被其他类继承后，它们可以具有不同的数据类型或表现出不同的行为，这使得同一个属性和方法在不同类中具有不同的语义。

在一个类中定义的方法如果同时满足以下三个条件，该方法称为构造方法，具
体如下:
1、方法名与类名相同
2、在方法名的前面没有返回值类型的声明
3、在方法中不能使用return语句返回一个值，但是可以单独写return语句来作为方法的结束。

与普通方法一样，构造方法也可以重载，在一个类中可以定义多个构造方法只要每个构造方法的参数类型或参数个数不同即可。在创建对象时，可以通过调用不同的构造方法来为不同的属性进行赋值。

在一个Java类中，可以使用static关键字来修饰成员变量，该变量被称作静态变量。静态变量被所有实例共享，可以使用“类名.变量名”的形式来访问。

注意: static关键字只能用于修饰成员变量，不能用于修饰局部变量否则编译会报错。

要实现这样的效果，只需要在类中定义的方法前加上static关键字即可，通常称这种方法为静态方法。同静态变量一样，静态方法可以使用“类名.方法名”的方式来访问，也可以通过类的实例对象来访问。

注意:在一个静态方法中只能访问用static修饰的成员，原因在于没有被static修饰的成员需要先创建对象才能访问，而静态方法在被调用时可以不创建任何对象。

应用程序想完成具体的功能，仅有类是远远不够的，还需要根据类创建实例对象。在java程序中可以使用new关键字来创建对象，具体格式如下：

类名 对象名称 =new 类名（）;

例如，创建person类的实例对象代码如下：

person p=new person（）；

每个对象都有生命周期，当对象的生命周期结束时，就会销毁