Java学习笔记

时间 2019-11-21

标签 java 学习笔记栏目 Java 繁體版

原文原文链接

一、读输入java

Scanner in=new Scanner(System.in);//in这个对象作读入下一行的操做
System.out.println(in.nextLine());//System.out这个对象打印下一行

二、数组数组

其中全部的元素都具备相同的数据类型

int []s=new int[maxn];//数组定义  new建立的数组会获得默认的0值 建立maxn个int型数组
int []s={1,2,3,4};//直接初始化数组 能够不用给出大小

有成员函数length可直接使用
    
    数组变量是  ！**数组的管理者**！而非数组自己！
    
    数组必须建立出来交给数组变量管理，数组变量之间的赋值是**管理权限**的赋予，
    数组变量之间的比较是判断**是否管理同一个数组**
    eg.   s是有maxn个元素的数组的管理者

三、包裹类型框架

基础类型       包裹类型
        boolean       Boolean
        char          Character
        int           integer
        double        Double

能够经过包裹类型获取该类型的最大最小值，判断是不是字母什么的能够有更多的功能扩展dom

四、Math类ide

Math.abs(-12);//12
    Math.pow(2,3);//8.0 浮点运算
    Math.random();//生成0~1之间的随机数  能够*100 获取0~100之间的随机数
    Math.round();//四舍五入

五、字符串函数

字符串变量并不存放字符串，也不是字符串全部者，它是**字符串的管理者**
    Java的字符串是”不可变“对象，全部对字符串的操做都是产生一个新的字符串，
    而不是对原来的字符串进行修改
    
    String的变量是对象的管理者
    eg.    String s=new String("a string");//建立了一个String的对象，并初始化
            //建立了这个对象的管理者s 让s管理这个对象
    输入字符串，in.next；//读入一个单词,以空格为界  in.nextLine();读入一整行
    
    字符串的比较:
    if(input=="bye")  比较的是 是否指向的是同一个String对象 很大可能return false
                       由于input和"bye"是两个不一样的字符串
    if（input.equals("bye") 才是比较内容是否相同
    
    对字符串的操做：
    s.charAt(index);//返回在index上的单个字符 0~length()-1
    //注意 不能用for-each循环来遍历字符串  for(char c:s){}不行
    //for-each只适合于数组或者可枚举类型
    s.substring(n);//获得从n号位置到末尾的所有内容
    s.substring(b,e);//b号位置到e号位置以前的内容 左闭右开
    s.indexOf(c);//获得c字符所在位置，-1表示不存在
    s.indexOf(c,n);//从n号位置开始找
    s.indexOf(t);//找到字符串t所在位置 返回值为子串开始的index
    s.lastIndexOf();//从右边开始找
    
    eg.要找一个串中的第二个3  String s="0123453";
       int loc=s.indexOf('3');
       s.indexOf('3',loc+1);
    
    s.startsWith(t);//s是不是以字符串t开头的
    s.endsWith(t);
    s.trim();//把字符串两端的空格删掉
    s.replace(c1,c2);//全部的c1换成c2
    s.toLowerCase();//全部字符都变成小写
    s.toUpperCase();

六、本地变量不会被自动初始化有可能会报错，因此要记得初始化布局

本地变量：定义在函数内部,做用域和生存期都在函数内部，
而成员变量（自动初始化为0或null）的生存期是对象的生存期，做用域是类内部的成员函数

七、类和对象this

VendingMachine v=new VendingMachine();//对象变量是对象的管理者

v.insertMoney()中使用的成员变量是v的成员变量实际上**是经过this实现的**

this:spa

this是成员函数的一个特殊的固有的**本地变量**，它表达了调用这个函数的 **那个对象**
在成员函数内部直接调用本身的其余函数，也能够经过this来实现(一般会省略）

一个类的成员变量能够是其余类的对象设计

八、封装：把数据和对数据的操做放在一块儿，而且用这些操做把数据掩盖起来（面向对象核心概念）

直接手段：
    类的全部成员变量必须是private的
    全部的public的函数，只是用来实现这个类对象或类本身要提供的服务的，而不是用来直接访问数据。

private（类所私有的）只能用于成员变量和成员函数:

public class Display{
    private int num;
    private int getValue(){    };//不能够在getValue函数中定义变量的时候使用private
}

注意：

只有这个 类内部（类的成员函数和定义初始化） 能够访问
这个限制是对类的，而不是对对象的
//private定义的变量，限制其余类的对象访问本类对象的这个变量，但不限制本类的其余对象访问奔雷的private数据

public class Fraction{
    private int a;
    private int b;
    public Fraction plus(Fraction r)
    {
        int fenzi=a*r.b+r.a*b;//这个彻底能够实现哦，由于private的限制不是对对象的，他们都在Fraction类里
        int fenmu=b*r.b;
        return new Fraction(fenzi,fenmu);
    }
}

九、包

十、类变量和类函数

类是描述，对象是实体
在类中所描述的成员变量，其实是位于这个类的各自的对象中的
可是若是某个成员由static关键字修饰，它就变成了属于整个类的了
每一个对象均可以访问到这些类变量和类函数而且能够直接经过名字调用
类函数不属于任何对象，没法创建与调用他们的对象的关系，也就不能直接访问任何非static的成员变量和成员函数,必需要经过对象进行调用
this表示当前本对象，类函数和对象没有任何关系，因此类函数没有this
经过一个类的对象对static变量进行了修改，那么其余对象中的这个变量的值也都被修改了，由于这个变量是类的，而不是单独某一个对象的
能够经过 类.static型变量 对该变量进行访问
static变量只能被初始化一次,在第一次类的装载的时候被初始化

十一、对象容器
究竟把什么放进容器里了？对象的管理者.

泛型类：eg. ArrayList 这种泛型类是一种容器
无限放东西，计算机有容量就能一直放，数组没法实现，要用容器实现

容器类有两个类型：容器的类型（ArrayList）、元素的类型（String)

import java,util.ArrayList;
public class NoteBook{
    private ArrayList<String> notes=new ArrayList<String> ();
    //ArrayList类中经常使用成员函数
    //notes.add(s);  notes(location,s);//把s放在原来location前面，即放在location位置，原来location位置之后的东西顺序后移
    //notes.size();
    //notes.remove(index);
    //notes.toArray(a);//把这个ArrayList里的元素都复制到a数组中，而后进行输出,以下图所示，能够省略一个循环
}

十二、对象数组

当数组的元素的类型是类的时候，数组的每个元素都只是对象的管理者而非对象自己，
仅仅建立数组并不意味着建立了其中的每个对象,String[] a=new String[10]，此时对象尚未建立出来,若是是int，则会产生a[0]=0;

for-each循环

for(int k:ia){  k++;  }//没有任何用，由于这里的k只是原数组的复制品
对于对象数组却有所不一样
由于 数组管理的那块东西 和 for-each循环里那个东西管理的 是同一个东西，会实现修改

1三、集合容器

HashSet<String> s=new HashSet<String>();//集合不保存重复键值
System.out.println(s);//能够直接输出 [second,first]  ArrayList也能够
//由于他们都实现了toString
public String toString(){
    return ""+s[i];
}

class Value{
    private int i;
    
}

main(){
    Value v=new Value();
    v.set(10);
    System.out.println(v);//输出的是奇怪的东西，继续在Value类里实现toString才可以输出
                            //return ""+i;
}

注意：

集合容器中的元素不是在一块连续的存储空间内的，各个元素的位置是不连续且无序的，因此没法用index去索引任何一个元素的地址**（集合是无序的）** 所以，也不能用get()来获取某个位置的元素

1四、散列表

HashMap<Integer,String> m=new HashMap<Integer,String>();//注意不能是int,由于在容器中全部元素都必须是对象
m.put(key,value);
m.get(key);//能够获取到对应的value
m.keySet();//获取Set中不重复的键值个数
//一样也能够直接用println输出m

1五、继承与多态

子类能够继承获得父类的全部东西（构造方法除外，它是每一个类所独有的），但并不表明所有可使用。
每一个成员有不一样的访问属性

父类成员访问属性   在父类中的含义                   在子类中的含义
public          对全部人开放                     对全部人开放
protected       只有包内其余类、本身和子类能够访问   只有包内其余类、本身和子类能够访问
private         只有本身能够访问                  不能访问
缺省             只有包内其余类能够访问             若是子类和父类在同一个包内：只有包内其余类能够访问 不然，至关于private，不能访问

protected:包内和子类可访问
缺省：在父类所在的包内可见，若是子类和父类不在一个包中，则也不能访问

private型变量在子类中也是存在的，只是不能直接访问，在子类中也不能更改他们的属性，若是定义了一个同名变量，则是与父类里面那个无关的独立的一个变量

构造一个子类对象时，先回调用父类的构造函数，再调用本身的，父类空间先被初始化，而后子类空间才会被初始化。这样就有可能会出现问题。
若是父类的构造函数是有参构造函数，那么子类如何给他传参呢？？
这里用到的是super(title); 父类构造函数会根据super中的参数去寻找它里面合适的构造函数

关于super:

//super是用来给父类传递参数的
super();//一个构造函数中只能使用一次super**（由于只有一个父类呀）**，而且super要放第一行

子类和父类中都有print();时用super.print();调用父类的

多态变量

对象变量能够保存其声明的类型的对象，或者该类型的**任何子类型的对象**
保存**对象类型**的变量是**多态变量**（是指一个变量能够保存不一样类型的对象）

子类的对象能够被看成父类的对象来使用：

赋值给父类的变量
传递给须要父类对象的函数
放进存放父类对象的容器里

Java中全部对象变量都是多态的，他们能保存不止一种类型的对象

他们能够保存声明类型的对象，或声明类型的子类的对象
当把子类的对象赋值给父类的变量（不是对象对对象的赋值，而是让这两个东西管理同一个东西）的时候——发生了向上造型
```
*C++里面能够作对象对对象的赋值，但Java不能*
```

Vechicle v;
Car c=new car();
v=c;
c=v;//编译错误，父类的对象不能赋值给子类的变量
c=(Car)v;//v实际管理的是Car类型才行   （造型：声明类型和动态类型（实际传递进去的）不符）
//这样可能有风险 取决于v当时管理的对象是什么 只有它管理Car类型时才能被成功造型
//造型（括号围起来）：对象自己并无发生任何变化，当作另外一个类型来看待，不是“类型转换”
//运行时有几只来检查这样的转化是否合理  eg.  ClassCastException

多态

子类方法覆盖了父类方法，但具备相同的方法名称和参数表，仍然是父类中定义的那个方法，不过是新版本，子类对象调用执行子类本身的这个方法，父类对象执行父类的
注意是对象而非变量，由于一个类型为父类的变量有可能指向的是一个子类的对象

函数调用的绑定：经过对象变量调用函数时，调用哪一个函数

静态绑定：根据变量的声明类型决定
动态绑定：根据变量的动态类型决定（默认）//运行的时候才知道是什么类型

在成员函数中调用其余成员函数也是经过this这个对象变量来调用的
因此全部成员函数的调用都应该看作是动态调用

覆盖(override)

子类方法和父类方法具备相同的方法名称和参数表的一对函数构成覆盖关系
经过父类变量调用存在覆盖关系导函数时，取决于**当时所管理的对象的类**的函数

Object类

全部的类都是继承自Object的
成员函数：
```
toString();
       equals();
```

向下造型:

public boolean equals(Object obj){//以前穿传去的是CD类型，因此下面要作一个向下造型
    CD cc=(CD)obj;
    return artist.equals(cc.artist));
}

@Override

告诉编译器覆盖了父类的函数，注意**括号参数类型也会不能改的哦，public也不能去掉** 会产生编译错误，加了@的话

1六、抽象

抽象类（abstract)不能建立任何对象，仅仅表达接口，而不具体实现细节。可是**能够定义变量**，要**继承了这个抽象类的对象**才能够赋给这个变量。

eg:

class Circle{...}
Shape c;
c=new Circle();//c实际是管理了子类的对象

抽象类中能够实现抽象方法，也用abstract修饰，抽象方法是不彻底的，它只是一个方法签名而彻底没有方法体。

若是一个类有了抽象方法，这个类就**必须声明为抽象类**。

若是父类是抽象类，子类就必须**覆盖(即实现）全部**在父类中的抽象方法，不然子类也成为一个抽象类

public abstract class Shape{
    public abstract void draw(Graphics g);//注意不能有{}，否则就会报错
}

1七、接口：规定长啥样

接口（interface)是纯抽象类
全部的成员函数都是抽象函数
全部的成员变量都是public static final

Cell是一个接口类型，Field若是想要一个Cell,此时Fox和Rabbit都实现了这个接口，从而他们能够做为Cell给Field使用。

public interface Cell{//interface和class是同一级别，能够说是一种特殊的类
    void draw(Grphics g,int x,int y,ints size);
}

类用extends,接口用implements
类能够实现不少接口
接口能够继承接口，可是不能继承类
接口不能实现接口
设计程序时，要先定义接口，再实现类
任何须要在函数间传入传出的必定是接口而不是具体的类？？？留坑不是很懂

1八、instanceof

if(an instanceof Rabbit)//用于判断an是否是Rabbit类型的变量

20、内嵌类型：在类或接口内部定义的自定义类型

class A{//包围类
    static class B{ static int x;}//内部类  可添加雨多成员函数才能具有的东西，eg. static,private
    interface C{int y=0;}//内部接口
}//编译后将产生三个文件：A.class  A$B.class A$C.class

内部类能够访问囿类全部成员，包括私有
要访问内部类，须要经过囿类或囿类对象来访问
若是要将囿类对象自身传给内部类对象：囿类对象名.this
外部类和内部类能够任意互访，可是外部类要经过建立内部类的对象来访问内部类
若 内部类 中有静态成员，则这个内部类必须是静态内部类才可以经过A.B.x直接调用起哄的静态成员

2一、GUI图形界面

JButton类：能够实现一个按钮JButton bt=new JButton("单步");
JFrame类：实现一个框架

Swing：

全部东西都是部件,放在容器中,容器管理部件的时候会使用布局管理器(五个方位参数）,默认是BorderLayout;
采用事件监听器的事件处理模型，某个对象实现相关接口就能够成为相关事件的监听器，就能够注册到它想监听的组件上。

frame.add(bt,BorderLayout.NORTH);//必定要注意指定位置，不然会覆盖掉以前的东西
//由于参数缺省的时候默认是center,会覆盖掉前面的

//匿名类
bt.addActionListener`(`   new ActionListener(){
    public void actionPerformed(ActionEvent e){
        ...
    }
}   `)` //ActionListener里面只有actionPerformed()函数

在new对象的时候给出类的定义造成匿名类
匿名类能够继承某类，也能够实现某接口
Swing的消息机制普遍使用匿名类

//内部类
class StepListener implements ActionListener{
    public void actionPerformed(ActionEvent e){
        ...
    }
}

bt.addActionListener(new StepListener());//注意传进去要是实现了ActionListener的对象

定义在别的类、函数内部
能直接访问外部类的资源，包括私有
外部是函数时，只能访问那个函数里final的变量

反转控制
把一个实现了ActionListener接口的对象交给JButton（注册），JButton就能反过来去调用里面的actionPerformed()函数，实现相关操做。（也叫Swing的消息机制）

MVC模式

2二、异常处理

import java.util.Scanner;
class test
{
    public static void main(String[] args) {
        int []a=new int[10];
        int idx;
        java.util.Scanner in=new Scanner(System.in);
        idx=in.nextInt(); 

        try{
            a[idx]=10;
            System.out.println("hi");
        }catch(ArrayIndexOutOfBoundsException e)
        {
            System.out.println("caught");
        }
        catch(Typel e){
           ...
        }
        ...
    }
}//try-catch语句捕获异常,后面能够跟着不少catch

拿到异常对象以后：
String getMessage();
String toString();
void printStackTrace();

若是没办法处理，能够再度抛出

catch(Exception e){
    System.err.println("An exception was thrown");
    throw e;
}//(若是在这个层面上须要处理，可是不能作最终的决定，就继续抛出，给下一个catch处理）

什么能扔？

任何继承了Throwable类的对象//throws XX
Exception类继承了Throwable
throw new Exception()
throw new Exception("HELP");//两种形式

catch怎么匹配？
Is-A关系
抛出自诶异常会被捕捉父类异常的catch捉到

能捕捉到任何异常：

catch(Exception e){
    System.err.println("Caught an exception");
}

若是你的函数可能会抛出异常，就必须在函数头部加以声明

void f() throws TooBig,TooSmall{
    ...
}

2三、I/O流