1:计算 Scanner
in = new Scanner(System.in);//输入,任何需要读用户输入的程序都需要、
System.out.println("其他"+in.nextline);//连接两段话
System.out.println(in.nextline);
//让in去读入下一行,结果交给System.out去打印
System.out.println("2+3"+(2+3));//加减法
2:变量:输入一个变量进行计算
Scanner in = new Scanner(System.in);
int num;
num=in.nextInt();//num的值等于下一行读入的整数
System.out.println("100-"+a+"="+a));
3:定义常量:
final int a=10;
final即a的值不能更改
4:判断浮点数是否相等:
System.out.println(Math.abs(a-b)<1e-6));
5:定义数组:
定义一维数组:
<类型>[] <名字>= new <类型>[元素个数];
int [] number=new int[100];
得到数组的大小:number.length
定义二维数组:
<类型>[][] <名字>= new <类型>[元素个数][元素个数];
int [][] number=new int[100][100];
6:定义函数:
<返回类型> <方法名称>(<参数表>) {
<方法体>
}
7:包裹类型:
将一个基本数据类型的数据转换成对象的形式,从而使得它们可以像对象一样参与运算和传递。
基本类型 包裹类型
boolean Boolean
char Character
byte Byte
short Short
int Integer
long Long
float Float
double Double
8:类和对象
1. 类的定义:
把相似的对象归成一个类,定义通用于一个特定种类的所有对象的属性(变量)和行为(方法)
[访问权限控制符] class 类名{
类的成员
}
修饰符一般为public,也可不写。类名一般大写
2. 类的成员:
类(class) :是对某一类事物的描述
➢成员变量(属性)
➢成员函数(方法)
➢通过"."调用属性和方法
3. 对象:
是实际存在的某类事物的个体,也称为实例
创建对象:类名 对象名=new 构造函数
e,g:Employee zhang = new Employee( )//实例化对象
举例:
//构建类(学生成绩)
public class student {
//属性
public string nane;//姓名
public int score;//分数
//构造方法
public Student(String name ,int score){
this . name-name;//加this就近原则
this . score=score;
}
//输出信息
public void showInfo(){
System. out . println(name+ "的成绩是”+score);
}
}
public class Test {
public static void main(String[] args) {
Student s1=new Student(" anna" ,90);//定义对象s1
s1. showInfo();//调用输出信息方法
Student s2=new student("tom" ,80) ;
s2. showInfo();
}
}
4. this关键字:
代表对象自身的引用,通常在类的方法定义中使用
用this关键字的情况
- 方法中的变量与成员变量重名
- 在一个构造方法中,调用其它重载的构造方法
- 返回当前对象的引用
5. 方法的重载:
函数的重载就是在同一个类中允许同时存在一个以上同名的函数
方法重载的规则:
- 函数名称相同,函数的参数不同(参数个数不同或参数类型不同)
- 函数的返回值类型可以相同,也可以不同
9:面向对象的思想(oop)
面向过程e ,g:
void Openlcebox(){
printf("把冰箱门打开\n");
}
void PutElephantl(){
printf("把大象放冰箱\n");
}
void Closelcebox(){
printf(“把冰箱门关上In");
}
int main()
{
Openlcebox();
PutElephantin();
Closelcebox();
}
面向对象e ,g:
public class.Icebox {//把things放入冰箱
static void putThings(String things){
System.out.printin("把冰箱门打开");
System.out. printin("把" +things+"放进来");
System.out.println("把冰箱门关上");
}
}
public class Mine {//传入参数things
public static void main(String args[]){
Icebox.putThing$("大象");
}
}
三个特征
(1)继承:父类基类->子类派生类
- 在Java中定义一个类时,通过关键字extends继承一个已有的类
- 被继承的类称为父类(超类,基类),新的类称为子类(派生类)。
- 子类继承父类的所有属性和方法,同时也可以增加自己的属性和方法。
继承的规则
- Java只支持单继承,子类只能有一个父类,一个父类可以有多个子类
- 子类继承父类所有的属性和方法,但不继承父类的构造方法
类的继承格式
class 父类 {
}
class 子类 extends 父类 {
}
子类的构造方法:
1:使用默认的构造方法
2:在子类中的创建构造方法
3:在子类中创建构造方法时,必须调用父类的构造方法
子类可以在自己的构造方法中使用super关键字来调用父类的构造方法
super (参数1,参数2,..);
➢super关键字调用父类构造方法,必须写在该子类构造方法第一行
➢如调用的是父类中无参的构造方法,则可以不写super( )
➢子类调用无参构造方法,而父类没有无参构造方法则系统编译出错
◆访问父类构造方法 super(); super(name);
◆访问父类属性 super.name;
◆访问父类方法 super.print();
Object类是所有类的父类
public class Pet extends Object {
.....
}
Object类被子类经常重写的方法
toString() 返回当前对象本身的有关信息,按字符串对象返回
equals() 比较两个对象是否是同一个对象,是则返回true 操作符= hashCode() 返回该对象的哈希代码值
getClass() 获取当前对象所属的类信息,返回Class对象
(2)封装:
封装:将类的某些信息隐藏在类内部,不允许外部程序直接访问,而是通过该类提供的方法来实现对隐藏信息的操作和访问
步骤:
1:修改属性可见性为private
2:创建共有setter/getter方法
3:对属性合法性进行判断
(3)多态:
相同的父类引用,不同的子类实例,执行相同的行为,产生不同的结果(父类引用,子类对象)
买现多态的两个要素:1.方法重写 2.使用父类类型
//abstract即为抽象类:
1:抽象类不能被实例化,即不能
public abstract class Pet(){
}
Pet p=new Pet();
2:抽象类里面必须要有抽象方法,
3:抽象类的抽象方法必须被子类实现
实例;
abstract class Printer(){//父类
print(String str);
}
class ColorPrinter (){//子类
print(String str) {
System.out.printin("输出彩色的"+str);_
}
}
class BlackPrinter (){
print(String str) {
System.out.printIn("输出黑白的"+str;
}
}
public static void main(String[] args){//运行
Printer p=new ColorPrinter();
p.print();
p = new BlackPrinter();
p.print();
}
方法重写:
◆在继承关系的子类中
◆重写的方法名、参数、返回值类型必须与父类相同
◆私有方法不能继承因而也无法重写
方法重写与方法重载的区别:
位置 参数表 返回值 访问修饰符
方法重写 子类 相同 相同. 相同 不能比父类更严格
方法重载 同类 相同 不同 无关 无关
位置 | 方法名 | 参数表 | 返回值 | 访问修饰符 | |
---|---|---|---|---|---|
方法重写 | 子类 | 相同 | 相同 | 相同 | 不能比父类更严格 |
方法重载 | 同类 | 相同 | 不同 | 无关 | 无关 |
instanceof运算符:
用于判断一个对象是否属于一个类或连接接口,结果返回true或false
检查对象真实性,避免类型转换异常
if(对象 instanceof 类){
......
}else if(对象 instanceof 类){
......
}
10:接口:
public interface MyInterface{
public void 能力();
}
接口的特性
◆接口不可以被实例化
◆实现类必须实现接口的所有方法
◆实现类可以实现多个接口 //即 多继承
◆接口中的变量都是静态常量
举例USB接口:
//编写接口
public interface usbinterface {
//接口的能力
void service();
}
//实现接口
public class UDisk implements UsbInterface {
//关键字implements是一个类,实现一个接口用的关键字
public void service() {
System.out.print("连接USB接口,实现传输数据");
}
}
public class UsbFan implements UsbInterface {
public void service() {
System. out. print("连接USB接口,让电风扇转起来");
}
}
//使用接口
usbinterface UDisk=new UDisk();
UDisk.service();
usbinterface UsbFan=new UsbFan();
UsbFan.service();
implements和extends的区别:
extends是继承类,implements是实现接口。
类只能继承一个,接口可以实现多个。
extends可重写父类的方法,也可调用父类的非私有方法;implements必须实现接口的所有方法。
面向接口编程:
public interface Lock{ //接口锁
//锁的能力
public void openlock();//开锁
public void closelock();//关锁
}
public interface DoorBell{ //接口
//DoorBell的能力
public void takephoto();//拍照
}
public abstract class Door{ //门 抽象类
//门的能力
public abstract void open();//开门
public abstract void close();//关门
}
public class TheftproofDoor extends Door implements Lock,DoorBell {
//建立一个TheftproofDoor类继承Door使用Lock,DoorBell接口
public void openlock() {
system.out.println("插进钥匙 锁上了 拔出钥匙");
}
public void closelock() {
system.out.println("插进钥匙 打开了 拔出钥匙");
}
public void open() {
system.out.println("推门");
}
public void close() {
system.out.println("拉门");
}
public void takephoto {
system.out.println("拍照存档了");
}
}
public class DoorTest {//编写测试类
public static void main(String[] args) {
TheftproofDoor tfd=new TheftproofDoor(); //实例化对象
tfd.open();
tfd.close();
tfd.LockUp();
tfd.openLock();
tfd.takephoto();
}
}
多个接口之间用","分隔