- 简单、面向对象、与平台无关、多线程、动态
- 由字母、下划线、美元符号、数字组成
- 第一个字符不能是数字
- 标识符不能是关键字;不能是truefalsenull
- 编写源文件:使用文本编辑器编写源文件。将编写好的源文件保存,源文件的扩展名必须是.java
- 编译源文件:使用Java编辑器(javac.exe)编译源文件,得到字节码文件(扩展名是.class)
- 运行程序:使用Java SE平台中的Java解释器(java.exe)来解释,执行字节码文件
- 源文件中可以有多个类,但最多一个类是public类
- 如果源文件中有public,源文件名必须要和public类的名字完全相同;如果源文件中没有public类,源文件名只需要和某个类的名字相同
- 源文件的扩展名是.java;字节码文件扩展名是 .class
- 一个Java应用程序中必须有且仅有一个类含有main方法(public static void main(Sting args[]),称这个类为主类
- 整型常量:
- 十进制:无前缀
- 八进制:0做前缀
- 十六进制:0x或0X做前缀
- 字符型常量:
- 单个字符:用单引号’ ’括起来
- 字符串常量:用双引号" "括起来
- 实型合法常量:
- float:必须要有后缀f或F,存储时保留8位有效数字
- double:可以有后缀d或D,存储时保留16位有效数字
- 字符采用ASCII编码
逻辑运算符:
+、-、*、/;
a+=b;//a=a+b;
a-=b;//a=a-b;
自增:a++(执行完代码后,再自增,即先用后加) a=a+1
++a(执代码前,先自增,即先加后用)
自减同理a--、--a
幂运算:需要用工具函数来执行;
位运算符:
&&(与)、||(或)、!(非)
- a&&b 与运算 有假为假
- a||b 或运算 有真为真
- !a、!b 非运算 假为真,真为假
- !(a&&b)异或运算 同号为假,异号为真
短路运算:当*与运算*时,若靠左的逻辑运算若为假,则不继续走右边逻辑运算,直接结束运算。
A=0011 1100
B=0000 1101
-----------------------------
A&B 0000 1100(都为1则为1,有一个非1为0);
A|B 0011 1101(都为0则为0,存在一个1直接为1);
A^B 0011 0001(相同为0,不同为1);
~B 1111 0010(取反)
2<<3 2左移3位 0000 0010->0001 0000 则结果为16
>>右移除二
<<左移乘二
三元运算符
//? :
//x?y:z (如果x==true,则结果为y,否则为z)
数据类型转换:自动转换条件、以及何种情况下需要强制转换与语法格式
-
自动转换条件:低精度转高精度
-
强制转换:高精度转低精度
-
强制转换语法格式:(类型名)要转换的值 例如:int x=(int)34.98
-
不能把一个高精度的变量直接赋值给低精度变量,因为编译器只会检查变量的类型而不是变量的值 例如有int x=1;byte y;不能y=x,必须y=(byte)x
-
注意点::
- 不能对布尔值(boolean,只能为其变量赋值true和false)进行转换
- 不能把对象类型转换为不相干的类型
- 高容量转换为低容量的时候强制转换可能内存溢出或者精度问题。
//强制转换:
int i=128;
byte b=(byte)i;
//自动转换:
int i=128;
double b=i;
条件运算符的使用
- 加减运算符、乘除求余运算符、自加自减运算符、关系运算符、逻辑运算符、赋值运算符、位运算符、intanceof运算符(二目运算符,左边是一个对象,右边是类,当左边的对象是右边的类或者子类创建的对象的时候,返回true,否则false)
(1)if语句、if~else语句
(2)switch语句
- switch后面的表达式的值不能是long型
- 表达式的值和case常量值匹配,匹配成功则执行当中的语句,直到遇到break语句;如果没遇到break,则进行下一个匹配
- 如果表达式的值不与任何一个case常量值相等,则执行default语句,default语句也可以没有,default语句可以在任意位置
(3)循环语句的结构(for、while、do-while)
- while与do-while的区别:do-while至少执行一次
(4)break和continue语句return语句使用的用法。
- break被执行,整个循环结束,不再执行循环语句
- continue被执行,本次循环结束,进入下一次循环
- return返回某个值
(5)以及它们的组合使用。
- 一维数组声明:
- 1.类型 数组名[](int a[])
- 2.类型 [] 数组名(int [] a)
int[]nums;//首选声明类型
int nums2[];//C语言风格
nums=new int[10];//创建一个数组
int [] num=new int [10];//创建与声明相结合
int [] numbers={10,20,30,40,50};//定义数组:
- 二维数组声明:
- 1.类型 数组名[][](int a[][])
- 2.类型 [][] 数组名(int [][] a)
- 一次声明多个数组:
- 类型 [] 数组名1,数组名2(声明两个数组a,b:int [] a,b)
- 一维数组分配元素:数组名=new 类型[个数](a=new int[3])
- 二维数组分配元素:数组名=new 类型[一维个数][二维个数](a=new int[2][3])
- 创建数组(声明并分配元素):如:int a[][]=new int[3][2]
- 数组初始化:如float a[]={21.f,34.23f,56,78f,90,12f}
- 数组属于引用型变量
- 成员变量:成员变量有默认值:
- 成员变量=属性=field(字段)
- 属性是类的一个组成部分,一般是基本数据类型,也可以是引用类型(对象、数组)
- 属性的定义语法同变量: 访问修饰符 属性类型 属性名;
- 对于boolean变量,默认值是false;
- 对于 byte short、int 和long 变量,默认值是0;
- 对于char 变量,默认值是’ ’(空宇符);
- 对于float和double 变量,默认值是0.0;对于“引用型”变量,默认值是null
- 成员方法:
1.成员方法(实例方法)内声明的变量是局部变量;
2.方法内声明的局部变量如果与成员变量的名字相同,那么成员变量被隐藏 - 构造方法:
1.构造方法没有返回值
2.构造方法的名字与类名一样
3.构造方法名可以一样,但必须参数类型或者参数个数不同(重载)
4.如果类中没有编写构造方法,那么系统会给一个默认的构造方法 - 对象:
1.创建:类名 对象名=new 类名()
2.对象属于引用型变量,存放的是引用值;创建对象分为声明和分配内存
3.对象可以调用类中的方法、自己的变量
| 属性 | 局部变量 |
|---|---|
| 有默认值,可以不赋值直接使用 | 无默认值,必须赋值在使用 |
| 可以被本类使用,或其它类使用(通过对象调用) | 只能在本类中对应的方法中使用 |
| 可以加修饰符 | 不可以加修饰符 |
| 可以重名,访问时准寻就近原则 | 在同一个作用域中比如在同一个成员方法中,两个局部变量不能重名 |
| 生命周期较长,伴随着对象的创建而创建,伴随着对象的销毁而销毁 | 生命周期较短,伴随着他的代码块的执行而创建,伴随着代码块的结束而销毁 |
- 实例变量(成员变量)在类体内方法外声明,与对象共存亡,在类中有效,有默认值,通过(对象名+.)访问
- 局部变量在方法内声明,与方法共存亡,在方法内有效(且与在方法内的位置有关),没有默认值,可以直接访问
- 用类声明的变量被称为对象。在用类声明对象后还必须创建对象,即为对象分配所拥有的变量。类是创建对象的模板,没有类就没有对象
- package语句:package 包名(包名可以是一个合法的标识符,也可以是若干个标识符加上”.”分隔而成;有包名的类的存储目录必须包含包名)
- import语句:表示引入一个包中的所有类,但可能会增加编译的时间
- 参数传递
-
值传递:向该参数传递的值的级别不可以高于该参数的级别,比如不可以向一个int型参数传递一个float值
-
引用传递:传递的是变量中的引用
- 基本数据类型赋值(值拷贝)
int n1=10; int n2=n1; n2=80; //输出n1为10;n2为80; //n2的变化不会影响n1的值
- 数组引用传递(地址拷贝)
int[] arr1={1,2,3}; int[] arr2=arr1; //赋的是一个地址,arr2的变化会影响到arr1 arr2[0]=10; //输出的arr1为 10 2 3
- this
1.构造方法中使用,代表使用该构造方法所创建的对象
2.实例方法中使用,代表正在调用该方法的当前对象 - super
1.用super操作子类隐藏的继承的成员变量和方法
2.用super调用父类的构造方法
- super注意点:
- super调用父类的构造方法,必须在构造方法的第一个/第一行
- super必须只能出现在子类的方法或者构造方法中。
- super和this不能同时调用构造方法,因为this()也只能放在构造器的第一行
- super和this的区别:
- 代表的对象不同
- this:本身调用者这个对象
- super:代表父类对象的应用
- 前提
- this:没有继承也可以使用
- super:只能在继承条件才能使用
- 构造方法:
- this():本类的构造
- super():父类的构造
- 代表的对象不同
- 公开级别 public 对外公开
- 受保护级别 protected 对子类和同一个包中的类公开
- 默认级别 没有修饰符号 向同一个包的类公开
- 私有级别 private 只有类本身可以访问,不对外公开
访问修饰符的访问范围:
注意事项
- 修饰符可以用来修饰类中的属性,成员方法以及类
- 只有默认和public才能修饰类,并且遵循上述访问权限的特点
- 成员方法的访问规则和属性完全一样
- 类的私有成员只供本类调用(当声明了一个私有成员变量时,但可以通过public方法来修改它的属性)
- 类的公共成员,可以被任何类调用
- private:本类
- protected:本类、同包类、不同包的子类
- public:所有类
- 缺省修饰符:本类、同包类
- 参数个数不同或者参数个数相同但是参数类型不同
- 是类的一种特殊方法,作用是完成对新对象的初始化,并不是创建对象。
基本语法:
[修饰符]方法名(形参列表){
方法体;
}
-
参数列表和成员方法一样的规则
-
构造器的修饰符可以默认,也可以是public、protected、private
-
构造器必须和类的名字相同
-
必须没有返回类型,也不能写void
-
构造器的调用,由系统完成
-
一旦定义了自己的构造器,默认的构造器就覆盖了,就不能再使用默认的无参构造器,除非故意的定义声明一下,即: Person(){}
-
如果没有定义构造器,系统会自动给类生产一个默认无参构造器
对象的创建和使用: -
必须使用new 关键字创造对象,设构造器 person mosun
- 对象的属性 mosun.name
- 对象的方法 mosun.run()
//构造器实例化初始值
//使用new关键字,必须要有构造器,本质是在调用构造器
//用来初始化值
//对象属性:字段field 成员变量
//默认初始化:
// 数字:0 0.0
// char:u0000
// boolean:false
// 引用类型:null
public Student(){
this.name="mosun"//没实例化之前类的对象为null
}
//有参构造(alt+insert默认生成有参):
public Person(String name){
this.name=name;
}
//================================================
public class pet {
public String name;
public int age;
public void shout(){
System.out.println("汪了一声");
}
}
public class 使用类 {
public static void main(String[] args) {
pet dog = new pet();
dog.name="messi";
dog.age=3;
dog.shout();
System.out.println(dog.name);
System.out.println(dog.age);
}
//输出汪了一声
//messi
//3
}
构造器重载:eg: 两个Person构造器,一个指定人名和年龄,一个只指定人名
class Person{
String name;
int age;
public Person(String pName,int pAge){//指定人名和年龄
name=pName;
age=pAge;
}
public Person(String pName){//只指定人名
name=pName;
}
}
静态成员变量和静态成员方法的使用 (选择题、判断题,程序阅读题)
- 声明成员变量时,用static修饰的称为静态成员变量(类变量)
1.所有对象共享类变量,也就是说改变一个对象的类变量其他对象的这个类变量也会改变,而每个对象的实例变量不同
2.也可以通过类名直接访问类变量 - 加static修饰的方法是类方法
1.类方法不可以操作实例变量
2.类方法要通过类名调用,不能通过对象调用
类方法发也叫静态方法
-
形式:访问修饰符 static 数据返回类型 方法名(){}
-
调用(满足访问修饰符的访问权限和范围):类名.类方法名或者对象名.类方法名
-
类方法和普通方法都是随着类的加载而加载,将结构信息存储在方法区:类方法中无this的参数(this代表当前对象,而static表示对象的共享,因此不能存在this在静态方法中)
- 普通方法中隐含着this参数
- 类方法中不允许使用和对象有关的该句子(this、super等)普通方法可以
-
普通方法和对象有关,需要通过对象名调用,不能通过类名调用
-
静态方法(类方法)只能访问静态变量或者静态方法
-
普通成员方法既可以访问非静态成员也可以访问静态成员
- 继承:一种已有的类创建新类的机制
- 多态:父类的某个方法被其子类重写时可以各自产生自己的功能行为
- 先调用父类的某个构造方法,再调用组合类的构造方法,最后调用子类自己的构造方法
- 上转型对象
- 不能调用子类新增的成员变量和方法
- 不能调用子类重写的static方法
- 不能调用隐藏的方法
- 重载:只看参数(参数类型或者个数不同)(返回类型和参数名字不参与比较)
- 重写:只有方法体不同(返回类型,方法名,参数都相同)
- 关键字abstract修饰
- 抽象类中可以有抽象方法也可以没有
- 抽象方法只允许声明,不允许实现,也就是没有方法体
- 抽象类不能用new标识符创建对象
- 如果一个非抽象类是抽象类的子类,那它必须重写父类的抽象方法;如果一个抽象类是抽象类的子类,那可以重写或者继承父类的抽象方法
接口(特殊的抽象)就是给出一些没有实现的方法,封装到一起,到某个类到使用的时候,再根据具体情况把这些方法发写出来
-
语法:
interface 接口名{ //属性 //方法(1. 抽象方法 2.默认实现方法 3.静态方法) } class 类名 implements 接口{ 自己属性; 自己方法; 必须实现的接口的抽象方法 } -
如果一个类implements(实现)接口,需要将该接口的所有抽象方法都实现
-
接口不能被实例化,不能被使用
-
接口中所有的方法都是public方法,接口中抽象方法,可以不用abstract修饰
-
一个普通类实现接口,就必须将该接口的所有方法都实现
-
抽象类实现接口时,可以不用实现接口的方法
-
一个类可以同时实现多个接口
-
接口中的属性,只能是final,而且是public static final修饰符
- 比如 int a=1;实际上是 public static final int a=1;
-
接口中属性的访问形式:接口名.属性名
-
一个接口不能继承其他的类,但是可以继承多个别的接口
-
接口的修饰符只能是public和默认(和类的修饰符一样)
-
接口与继承
- 继承满足is-a关系,接口只需满足like-a关系
- 当子类继承了父类,就自动的拥有父类的功能
- 如果子类需要拓展功能,可以通过实现接口的方式拓展
- 可以理解实现接口是对java单继承机制的一种补充
-
接口在一定程度上实现代码解耦(即接口规范性+动态绑定)
- 接口中只有常量而没有变量,抽象类中都可以有
- 抽象类强调的是继承关系和代码复用,而接口是针对一个行为的实现
异常:将程序执行中发生的不正常情况称为异常(语法错误和逻辑错误不是异常)
-
执行过程中发生的异常事件可分为两类
- Error(错误):JAVA虚拟机无法解决的致命严重问题
- Exception(异常):其他因编程错误或偶然的外在因素导致的一般性问题,可以使用针对性的代码进行处理
- 运行时异常:程序运行时发生的异常(编译器检测不出来)
- 编译时异常:编写程序时,由编译器检测出的异常
-
为保证程序的健壮性,如果程序员认为一段代码出现异常/问题,可以使用try-catch异常处理机制来解决
- 如果程序出现了异常,程序仍然可以继续执行
int num1=10,num2=0; int res= 0; // res = num1/num2;//分母为0,会报错导致执行失败(运行时异常) try { res = num1/num2;//选定指定代码后快捷键Ctrl+alt+t,选择try/catch } catch (Exception e) { e.printStackTrace(); System.out.println(e.getMessage());//输出异常信息:/ by zero }- 常见的运行时异常:
- NullPointerException空指针异常:当应用程序试图在需要对象的地方使用null时,抛出该异常
- ArithmeticException数学运算异常:当出现异常的运算条件时,抛出该异常(例如一个数除以0)
- ArrayIndexOutOBoundsException数组下标越界异常:用非法索引(索引为负或大于等于数组大小) 访问数组时抛出的异常
- ClassCastException类型转换异常:当试图将对象强制转换为不是实例的子类时,抛出该异常
- NumberFormatException数字格式不正确异常:当应用程序试图将字符串转换成一种数值类型,但该字符串不能转换为适当格式时(比如将mosun字符串转成整数时,Inerger.parseInt(“mosun”)),抛出该异常
-
try catch处理机制:程序员在代码中捕获发生的异常,自行处理
try{ 代码(可能有异常) }catch(Exception e){ //捕获到异常 //当异常发生时,系统将异常封装成Exception对象e,传递到catch //得到异常对象后,程序员自己处理异常 }finally{//可以没有 //不管try代码块是否有异常发生,始终要执行finally //所以通常将释放资源的代码放在finally上面 }-
如果异常发生了,则异常发生后面的代码不会被执行,直接进入到catch块
-
如果异常没有发生,则顺序执行try的代码块,不会进入到catch
-
如果希望不管是否发生异常,都执行某段代码(比如关闭连接、释放资源等)则可使用finally
-
可以进行try-finally 配合使用,这种用法相当于没有捕获异常,因此程序会直接崩掉。
- eg:执行一段代码,不管是否发生异常,都必须执行某个业务逻辑
try{ //代码 }finally{ //总是执行 } -
可以有多个catch语句,捕获不同的异常(进行不同的业务处理),要求父类异常在后,子类异常在前,比如(Exception在后,NullPointerException在前),如果发生异常,只会匹配一个catch
//try catch举例: public static void main(String[] args) { //如果输入的不是整数,提示反复输入,直到输入整数 Scanner scanner=new Scanner(System.in); int num=0; while (true){ System.out.println("请输入一个整数"); try { Integer.parseInt((scanner.next()));//可能抛出异常 break;//如果没有抛出异常则break该循环,因为若抛出异常了,则异常发生后面的代码不会被执行,直接进入到catch块 } catch (NumberFormatException e) { System.out.println("输入的不是整数,请重新输入"); } } } -
-
throws处理机制:将发生的异常抛出,交给调用者(方法)来处理,最顶级的处理者是JVM
- 如果一个方法(中的语句执行时)可能生成某种异常,但是并不能确定如何处理这种异常,则此方法应显示地声明抛出异常,表明该方法将不对这些异常进行处理,而由该方法地调用者负责处理
- 在方法声明中用throws语句可以声明抛出异常地列表,throws后面地异常类型可以是方法中产生的异常类型,也可以是它的父类
- 子类重写父类方法时,对抛出异常的规定:子类重写的方法,所抛出的异常类型要么和父类抛出的异常一致,要么为父类抛出的异常的类型的子类型
- 在throws过程中,如果有方法try-catch,就相当于处理异常,就可以不必throws
public void method() throws Exception1,Exception2,...,ExceptionN{ //可能产生异常的代码 }
1、教材P57 的程序阅读题1、2
1.
public class trytry {
public static void main(String args[]) {
char c=' ';
for(int i=1;i<=4;i++){
switch (i){
case 1:c='j';
System.out.print(c);
case 2:c='e';
System.out.print(c);
case 3:c='p';
System.out.print(c);
default:
System.out.print("好");
}
}
}//输出 jep好ep好e好好
}
-
public static void main(String args[]) { char a='你'; if(a>'A') System.out.println(1); else System.out.println(2); }//输出1
2、教材P120 的程序阅读题1、2、3、4
-
例一
public class trytry { static class Fish{ int weight=1; } static class Lake{ Fish fish; void setFish(Fish s){ fish=s; } void foodFish(int m){ fish.weight= fish.weight+m; } } public static void main(String args[]) { Fish redFish=new Fish(); System.out.println(redFish.weight);//1 Lake lake=new Lake(); lake.setFish(redFish); lake.foodFish(120); System.out.println(redFish.weight);//120+1 121 System.out.println(lake.fish.weight);//121 } } -
例二
public static void main(String[] args) { B b=new B(); b.setX(-100); b.setY(-200); System.out.println(b.getXYSum());//sum=100-200=-100 } } class B{ int x=100,y=200; public void setX(int x) { x = x;//此处无this,所以b.setX(-100)的值没有传进去,x仍然为100,sum=100-200=-100 } public void setY(int y) { this.y = y; } public int getXYSum(){ return x+y; } } -
例三
class A{ public static void main(String[] args) { B b1=new B(); B b2=new B(); b1.setN(3); b2.setN(5); int s1=b1.getSum(); int s2=b2.getSum(); System.out.println(s2); } } class B{ int n=0; static int sum=0; void setN(int n){ this.n=n; } int getSum(){ for(int i=1;i<=n;i++){ sum=sum+i;//s1之后sum为6,因此s2开始调用时sum以6开始,而不是0开始 } return sum; } } -
例4
public class A { public static void main(String[] args) { B b=new B(); System.out.println(b.f(10,10));//传递到int f(int x,int y),x*y=100 System.out.println(b.f(10,10.0));//传递到double f(int x,double y),x+y=20.0 } } class B{//方法的重载 double f(int x,double y){ return x+y; } int f(int x,int y){ return x*y; } }
3、教材P153 的程序阅读题1、2、3、4
-
例一
public class trytry { public static void main(String[] args) { B b=new B(); System.out.println(b.f(3,5));//3*5 15 System.out.println(b.f(3.0,5.0));//3.0+5.0 8.0 } } class A{ double f(double x,double y ){ return x+y; } } class B extends A{//B继承了A的方法,所以创造B对象时,也可以调用A的方法double f(double x,double y) int f(int x,int y){ return x*y; } } -
例二
class A{ public int getNumber(int a){ return a+1; } } class B extends A{ public int getNumber(int a){ return a+100; } public static void main(String[] args) { A a=new A(); System.out.println(a.getNumber(10));//11 此时调用的是A中方法 a = new B(); System.out.println(a.getNumber(10));//110 此时调用的是B中方法 } } -
例三
class A{ double f(double x,double y){ return x+y; } static int g(int n){ return n*n; } } class B extends A { double f(double x, double y) { double m = super.f(x, y);//访问父类方法 return m + x * y; } static int g(int n) { int m = A.g(n);//静态方法,无this和super,通过A.g()调用父类方法 return m + n; } } public class trytry { public static void main(String[] args) { B b=new B(); System.out.println(b.f(10.0,8.0));//98.0 先super访问了父类的f()方法得到m为18.0,再加上x*y 为98.0 System.out.println(b.g(3));//12 先A.g()调用父类g()方法得到m为9,再加上n 3 结果为12 A a=new B(); //当创建子类对象时,不管使用子类的哪个构造器,默认情况下总会去调用父类的无参构造器,如果父类没有提供无参构造器,则必须在子类的构造器中用super去指定使用父类的哪个构造器完成对父类的初始化工作 System.out.println(a.f(10.0,8.0));//98.0 同上 System.out.println(a.g(3));//9 直接访问父类的g方法 } } -
例四
class A{ int m; int getM(){ return m; } int seeM(){ return m; } } class B extends A { int m; int getM(){ return m+100; } } public class trytry { public static void main(String[] args) { B b=new B(); b.m=20; System.out.println(b.getM());//120 A a=b; a.m=-100; System.out.println(a.getM());//120 //上转型对象调用的一定是子类重写的getM() System.out.println(b.seeM());//-100 //子类继承色seeM()方法操作的m是被子类隐藏的m } }
4、教材P173 的程序阅读题1、2、3
-
例一
interface A{ double f(double x,double y); } class B implements A{ @Override public double f(double x, double y) { return x*y; } int g(int a,int b){ return a+b; } } public class trytry { public static void main(String[] args) { A a=new B(); System.out.println(a.f(3,5));//15 B b=(B)a; System.out.println(b.g(3,5));//8.0 } } -
例二
interface Com{ int add(int a,int b); } abstract class A{ abstract int add(int a,int b); } class B extends A implements Com{ @Override public int add(int a, int b) { return a+b; } } public class trytry { public static void main(String[] args) { B b=new B(); Com com=b; System.out.println(com.add(12,6));//18 A a=b; System.out.println(a.add(10,5));//15 } } -
例三
interface Com{ int add(int a,int b); public static int get(int n){ return n; } public default int see(int n){ return n; } public default int look(int n){ return n; } } class A implements Com{ @Override public int add(int a, int b) { return a+b; } @Override public int see(int n) { return n+1; } } public class trytry { public static void main(String[] args) { A a = new A(); int m=a.add(12,6);//18 int n=Com.get(12);//12 int t=a.see(6);//7 int q=a.look(6);//6 System.out.println(m+" "+n+" "+t+" "+" "+q); } }
5、教材P189 的程序阅读题1、2、3
-
例一
class Cry{ public void cry(){ System.out.println("hi"); } } public class trytry { public static void main(String[] args) { Cry hello=new Cry(){ public void cry(){ System.out.println("hello"); } }; hello.cry();//hello 内部类已经把cry方法重写了 } } -
例二
interface Com{ public void speak(); } public class trytry { public static void main(String[] args) { Com p=()->{ System.out.println("p是接口变量"); }; p.speak();//p是接口变量 } } -
例三
import java.io.IOException; public class trytry { public static void main(String[] args) { try { methodA(); }catch (IOException e){ System.out.println("hi"); return; }finally { System.out.println("fine"); } } public static void methodA() throws IOException{ throw new IOException(); } } //hi //fine
1、求数列之和(累积和) ,如:教材P51页 例子5,教材P51页 例子6
2、教材P58 的编程题1、3、5、6
- 1
public static void main(String[] args) { //求1到10的阶乘和 int sum=0; int m=1; for(int i=1;i<=10;i++){ m=i*m; sum+=m; } System.out.println(sum);//4037913 } - 3
public static void main(String[] args) { //求1+1/2!...前20项之和 double sum=0; double m=1; for(int i=1;i<=20;){ sum+=m; i++; m=m*(1.0/i); } System.out.println(sum);//1.7182818284590455 int i = 0; while(i<=20){ sum+=m; i++; m=m*(1.0/i); } System.out.println(sum);//1.7182818284590455 } - 5
public static void main(String[] args) { //求8+88+888...前十项之和 int num=8; double sum=0; for(int i=0;i<10;i++){ sum+=num; num=num*10+8; } System.out.println(sum);//1.286608608E9 } - 6
public static void main(String[] args) { //1+2+3...+n<8888,求n的最大正整数 int sum=0; int max=8888; int n; for ( n = 0; sum < max; n++) { sum+=n; if(sum>max){ n-=2; } } System.out.println(n);//132 }
3、设计一个圆形、矩形、三角形的类,计算面积、周长等(参考实验题及单元测试)
import java.lang.Math;
import java.util.Scanner;
abstract class Shape{
public abstract double area();
public abstract String getShapeName();
}
class Circle extends Shape{
public double r;
Circle(double r){
this.r=r;
}
public String getShapeName(){
String c="Circle";
return c;
}
public double area(){
return Math.PI*r*r;
}
}
class Rectangle extends Shape{
double height,width;
public String getShapeName(){
String r="Rectangle";
return r;
}
Rectangle(double height,double width){
this.height=height;
this.width=width;
}
public double area(){
return height*width;
}
}
class Triangle extends Shape{
double bottom,height;
public String getShapeName(){
String r="Triangle";
return r;
}
Rectangle(double bottom,double height){
this.bottom=bottom;
this.height=height;
}
public double area(){
return bottom*height/2;
}
}
class Calculator{
public void play (Shape shape) {
System.out.printf("%s:%.2f",shape.getShapeName(),shape.area());
}
}
public class Main{
public static void main(String[] args) {
Calculator calculator =new Calculator();
Scanner sc=new Scanner(System.in);
int ch=sc.nextInt();
switch(ch){
case 1:
double r=sc.nextDouble();
calculator.play(new Circle(r));break;
case 2:
double height=sc.nextDouble();
double width=sc.nextDouble();
calculator.play(new Rectangle(height,width));break;
case 3:
double bottom=sc.nextDouble();
double height=sc.nextDouble();
calculator.play(new Triangle(bottom,height));break;
default:
System.out.println("No corresponding shape!");
}
}
}
4、设计一个Point(二维图中的点)类,计算距离(参考实验题及单元测试)
public static class Point{
private double x;
private double y;
public Point(int x, int y) {
this.x=x;
this.y=y;
}
public double getX() {
return x;
}
public void setX(double x) {
this.x = x;
}
public double getY() {
return y;
}
public void setY(double y) {
this.y = y;
}
public int distance(Point p2) {
return (int) Math.sqrt(Math.pow((p2.x - this.x), 2) + Math.pow(p2.y - this.y, 2));
}
}
public static void main(String[] args) {
Point p1, p2;
int x1, y1, x2, y2;
Scanner sc = new Scanner(System.in);
x1 = sc.nextInt();
y1 = sc.nextInt();
x2 = sc.nextInt();
y2 = sc.nextInt();
p1 = new Point(x1, y1);
p2 = new Point(x2, y2);
System.out.println(p1.distance(p2));
}
5、教材P76例子6(求和)、教材P81例子8(圆锥组合圆对象)
-
例子6
public class trytry { public static void main(String[] args) { Computer com=new Computer(); int m=100; int n=200; int result=com.add(m,n); System.out.println(result);//300 result=com.add(120+m,n*10+8); System.out.println(result);//2228 } } class Computer{ int add(int x,int y){ return x+y; } } -
例子8
public class Circle { double radius,area; void setRadius(double r){ radius=r; } double getRadius(){ return radius; } double getArea(){ area=3.14*radius*radius; return area; } } public class Circular { Circle bottom; double height; void setBottom(Circle c){ bottom = c; } void setHeight(double h){ height =h; } double getVolume(){ if(bottom==null) return -1; else return bottom.getArea()*height/3.0; } double getBottomRadius(){ return bottom.getRadius(); } public void setBottomRadius(double r){ bottom.setRadius(r); } } public class Run1 { public static void main(String[] args) { Circle circle = new Circle(); circle.setRadius(10); Circular circular = new Circular(); System.out.println("circle的引用"+circle);//circle的引用comCircleAndCircular.Circle@96532d6 System.out.println("圆锥的bottom的引用"+circular.bottom);//圆锥的bottom的引用null circular.setHeight(5); circular.setBottom(circle); System.out.println("circle的引用"+circle);//circle的引用comCircleAndCircular.Circle@96532d6 System.out.println("圆锥的bottom引用"+circular.bottom);//圆锥的bottom引用comCircleAndCircular.Circle@96532d6 System.out.println("圆锥的体积"+circular.getVolume());//圆锥的体积523.3333333333334 System.out.println("修改circle的半径,bottom的半径同样变化");//修改circle的半径,bottom的半径同样变化 circle.setRadius(20); System.out.println("bottom的半径"+circular.getBottomRadius());//bottom的半径20.0 System.out.println("重新创建circle,circle的引用将发生变化");//重新创建circle,circle的引用将发生变化 circle=new Circle(); System.out.println("circle的引用"+circle);//circle的引用comCircleAndCircular.Circle@6108b2d7 System.out.println("但是不影响circular的bottom的引用");//但是不影响circular的bottom的引用 System.out.println("圆锥的bottom的引用:"+circular.bottom);//圆锥的bottom的引用:comCircleAndCircular.Circle@96532d6 } }



