java学习笔记1

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();
    }
}

多个接口之间用","分隔