面向对象（下）

类的继承
类的继承是指在一个现有类的基础上去构建一个新的类，构建出来的新类称为子类，现有类称为父类，子类会自动拥有父类所有可继承的属性和方法。（用extends关键字）
 
//定义Animal类
class Animal{
    String name;    //定义name属性
    //定义动物叫的方法
    void shout(){
        System.out.println("动物发出叫声。");
    }
}
//定义Dog类继承Animal类
class Dog extends Animal{
    //定义一个打印name的方法
    public void printName(){
        System.out.println("name = "+name);     //父类的name
    }
}
public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();//创建一个Dog类的实例对象
        dog.name = "tony";//为Dog类的name属性赋值
        dog.printName();//调用Dog类的printName（）方法
        dog.shout();//调用Dog类继承来的shout（）方法
    }
}
运行结果
name = tony
动物发出叫声。
 
注：①只支持单继承，不允许多重继承。②多个类可以继承一个父类。③多层继承是可以的，如A继承B，B继承C。
重写父类方法
在子类重写的方法要和父类被重写的方法具有相同的方法名、参数列表以及返回值类型。
//定义Animal类
class Animal{
    //定义动物叫的方法
    void shout(){
        System.out.println("动物发出叫声。");
    }
}
//定义Dog类继承Animal类
class Dog extends Animal{
    //这里重写父类，定义狗叫的方法
     void shout(){
        System.out.println("汪汪...");
    }
}
public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();//创建一个Dog类的实例对象
        dog.shout();//调用Dog类继承来的shout（）方法
    }
}
运行结果
汪汪...
注：子类重写父类方法时，不能使用比父类中重写的方法更严格的访问权限，如父类中的方法是public的，子类方法就不能是private。
super关键字
super关键字用于访问父类成员，例如访问父类的成员变量、成员方法和构造方法。
①使用super关键字调用父类的成员变量和成员方法。格式为：
super.成员变量
super.成员方法([参数1，参数2...])
例：
class Animal{
    String name = "动物";
    void shout(){
        System.out.println("动物发出叫声");
    }
}
class Dog extends Animal{
    //重写成员变量name
    String name = "犬类";
    //重写父类shout（）方法
    void shout(){
        super.shout();      //访问父类的成员方法
    }
    //打印name的方法
    void printName(){
        System.out.println("name = "+super.name);   //访问父类的成员变量
    }
}
public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.shout();
        dog.printName();
    }
}
运行结果
动物发出叫声
name = 动物
②使用super关键字调用父类的构造方法。格式为：
super([参数1,参数2...])
例：
class Animal{
    //定义Animal类有参的构造方法
    public Animal(String name){
        System.out.println("我是一只"+name);
    }
}
class Dog extends Animal{
   public Dog(){
       super("二哈");     //调用父类有参的构造方法
   }
}
public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
    }
}
运行结果
我是一只二哈
注：通过super调用父类构造方法的代码必须位于子类构造方法的第一行，并且只能出现一次。还有，在子类的构造方法中一定会调用父类的某个构造方法,可以通过super指定调用父类的某个构造方法，如果没有指定，实例化子类对象时，会自动调用父类无参的构造方法（这时如果父类中没有无参的构造方法，会报错）。
定义一个类时，如果没有特殊要求，尽量在一个类中定义一个无参的构造方法，避免被继承时出现错误。
class Animal{
    //定义Animal类无参的构造方法
    public Animal(){
        System.out.println("我只是一只动物");
    }
    //定义Animal类有参的构造方法
    public Animal(String name){
        System.out.println("我是一只"+name);
    }
}
class Dog extends Animal{
    //定义Dog类无参的构造方法
   public Dog(){
      //方法中无代码
   }
}
public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
    }
}
运行结果
我只是一只动物
final关键字
final关键字可用于修饰类、变量和方法，它有“这是无法改变的”或“最终”的含义。有以下特性：
①final修饰的类不能被继承
②final修饰的方法不能被子类重写
当在父类中定义某个方法时，如果不希望被子类重写，就可以使用final关键字修饰该方法。
③final修饰的变量（成员变量和局部变量）是常量，只能赋值一次。
注：使用final关键字修饰成员变量时，虚拟机不会对其进行初始化，因此使用final修饰成员变量时，需要在定义变量的同时赋予一个初始值。
抽象类
定义方法时不写方法体，该方法称为抽象方法，必须使用abstract关键字修饰。当类中包含了抽象方法，该类也必须使用abstract修饰，该类称为抽象类。
抽象类不可以被实例化，因为抽象类中的抽象方法没有方法体，不能被调用，如果想调用抽象类中的方法，需要创建子类，在子类中将抽象类中的抽象方法进行实现。
//定义抽象类Animal
abstract class Animal{
    //定义抽象方法shout（）
    abstract void shout();
}
//定义Dog类继承抽象类Animal
class Dog extends Animal{
    //实现抽象方法shout()
    void shout(){
        System.out.println("汪汪...");
    }
}
public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.shout();
    }
}
运行结果
汪汪...
接口
如果一个抽象类中所有的方法都是抽象的，则可以将这个类用另一种方式来定义，即接口。定义接口时，需要使用interface关键字来声明。
interface Animal{
    int ID = 1;     //定义全局常量
    void breathe();     //定义抽象方法
}
//接口中的变量默认使用“public static final”来修饰，即全局常量
//接口中定义的方法默认使用“public abstract”来修饰，即抽象方法
不能通过实例化调用接口中的方法，需要定义一个类，并使用implements关键字实现接口中的所有方法。
下面是类与接口之间实现的关系
//定义Animal接口
interface Animal{
    int ID = 1;     //定义全局常量
    void breathe();     //定义抽象方法breathe()
    void run();     //定义抽象方法run()
}
//Dog类实现了Animal接口
class Dog implements Animal{
    //实现breathe()方法
    public void breathe(){
        System.out.println("狗在呼吸");
    }
    //实现run()方法
    public void run(){
        System.out.println("狗在跑");
    }
}
public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.breathe();
        dog.run();
    }
}
运行结果
狗在呼吸
狗在跑
还可以定义一个接口使用extends关键字去继承另一个接口
//定义Animal接口
interface Animal{
    int ID = 1;     //定义全局常量
    void breathe();     //定义抽象方法breathe()
    void run();     //定义抽象方法run()
}
//定义了LandAnimal接口，并继承了Animal接口
interface LandAnimal extends Animal{
    void liveOnload();      //定义C抽象方法liveOnload()
}
//Dog类实现了LandAnimal接口
class Dog implements LandAnimal{
    //实现breathe()方法
    public void breathe(){
        System.out.println("狗在呼吸");
    }
    //实现run()方法
    public void run(){
        System.out.println("狗在跑");
    }
    //实现liveOnload()方法
    public void liveOnload(){
        System.out.println("狗生活在陆地上");
    }
}
public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.breathe();
        dog.run();
        dog.liveOnload();
    }
}
运行结果
狗在呼吸
狗在跑
狗生活在陆地上
注：①接口中的方法都是抽象的，不能实例化对象。②当一个类实现接口时，如果这个类是抽象类，则实现接口中的部分方法即可，否则需要实现接口中的所有方法（“class A implements B{}”A中的方法必须全在B中写出来，如果是“abstract class A implements B{}”则不需要全写）。③一个类通过implements关键字实现接口时，可以实现多个接口用逗号连接（class A implements B,C{}）。④一个接口可以通过extends关键字继承多个接口用逗号连接（interface A extends B,C{}）。⑤一个类在继承另一个类的同时还可以实现接口，此时，extends关键字必须位于implements关键字之前（class A extends B implements C{}    先继承，再实现）。
多态
在同一个方法中，由于参数类型不同而导致执行效果各异的现象就是多态。
为了实现多态，允许使用一个父类类型的变量来引用一个子类类型的对象，根据被引用子类对象特征的不同，得到不同的运行结果。
//定义接口Animal
interface Animal{
    void shout();
}
//定义Cat类实现Animal接口
class Cat implements Animal{
    //实现shout（）方法
    public void shout(){
        System.out.println("喵喵");
    }
}
//定义Dog类实现Animal接口
class Dog implements Animal{
    //实现shout（）方法
    public void shout(){
        System.out.println("汪汪");
    }
}
public class Test {
    //定义静态的animalShout（）方法，接收一个Animal类型的参数
    public static void animalShout(Animal an){
        an.shout();     //调用实际参数的shout（）方法
    }
    public static void main(String[] args) {
        Animal an1 = new Cat();     //创建Cat对象，使用Animal类型的变量an1引用
        Animal an2 = new Dog();     //创建Dog对象，使用Animal类型的变量an2引用
        animalShout(an1);       //调用animalShout（）方法，将an1作为参数传入
        animalShout(an2);       //调用animalShout（）方法，将an2作为参数传入
    }
}
运行结果
喵喵
汪汪
所以多态不仅解决了方法同名的问题，而且还使程序变得更加灵活，从而有效地提高程序的可扩展性和可维护性。
对象的类型转换
多态中，涉及到将子类对象当作父类类型使用的情况，如上面代码所写到的这两行：
Animal an1 = new Cat();        //将Cat对象当作Animal类型来使用
Animal an2 = new Dog();        //将Dog对象当作Animal类型来使用
注：此时不能通过父类变量去调用子类中的某些方法（这里的某些方法指的是子类中有的方法而父类中没有）。
//定义接口Animal
interface Animal{
    void shout();
}
//定义Cat类实现Animal接口
class Cat implements Animal{
    //实现抽象shout（）方法
    public void shout(){
        System.out.println("喵喵");
    }
    //定义sleep（）方法
    void sleep(){
        System.out.println("猫睡觉");
    }
}
public class Test {
    //定义静态的animalShout（）方法，接收一个Animal类型的参数
    public static void animalShout(Animal animal){
        animal.shout();     //调用传入参数Animal的shout（）方法
        //编译器检查到下面这行时，发现Animal类中没有定义sleep（）方法，会报错
        animal.sleep();      //调用传入参数Animal的sleep（）方法
    }
    public static void main(String[] args) {
        Cat cat = new Cat();     //创建Cat实例对象
        animalShout(cat);       //调用animalShout（）方法，将cat作为参数传入
    }
}
以上代码会报错，所以需要进行强制类型转换，将animalShout（）方法改为：
public static void animalShout(Animal animal){
    Cat cat = (Cat) animal;     //将animal对象强制转换为Cat类型
    cat.shout();     //调用传入参数Animal的shout（）方法
    cat.sleep();      //调用传入参数Animal的sleep（）方法
}
修改后运行结果
喵喵
猫睡觉
需要注意的是，在类型转换时也可能出现错误，当animalShout（）方法传入Dog类型的对象时，会报错，例：
//定义接口Animal
interface Animal{
    void shout();
}
//定义Cat类实现Animal接口
class Cat implements Animal{
    //实现抽象shout（）
    public void shout(){
        System.out.println("喵喵");
    }
    //定义sleep（）方法
    void sleep(){
        System.out.println("猫睡觉");
    }
}
//定义Dog类实现Animal接口
class Dog implements Animal{
    public void shout(){
        System.out.println("汪汪");
    }
}
public class Test {
    //定义静态的animalShout（）方法，接收一个Animal类型的参数
    public static void animalShout(Animal animal){
        Cat cat = (Cat) animal;     //将animal对象强制转换为Cat类型
        cat.shout();     //调用传入参数Animal的shout（）方法
        cat.sleep();      //调用传入参数Animal的sleep（）方法
    }
    public static void main(String[] args) {
        Dog dog = Dog();     //创建Cat实例对象
        animalShnew out(dog);       //调用animalShout（）方法，将cat作为参数传入
    }
}
程序运行会出错，原因是在调用animalShout（）方法时，传入一个Dog对象，在强制类型转换时，Animal类型的变量无法强转为Cat类型。
针对这种情况，Java提供了关键字instanceof，它能判断一个对象是否为某个类（或接口）的实例或者子类实例，如b instanceof A ，b为子类对象或者实现类对象，
语法：
对象（或者对象引用变量） instanceof 类（或接口）
对animalShout（）方法进行修改后
public static void animalShout(Animal animal){
    if(animal instanceof Cat){      //判断animal是否是Cat类的实例对象
        Cat cat = (Cat) animal;     //将animal对象强制转换为Cat类型
        cat.shout();     //调用传入参数Animal的shout（）方法
        cat.sleep();      //调用传入参数Animal的sleep（）方法
    }
    else
        System.out.println("这个动物不是猫");
}
运行结果
这个动物不是猫
使用instanceof关键字判断animalShout（）方法中传入的对象是否为Cat类型，如果是就进行类型转换，否则输出“这个动物不是猫”。
Object类
Object类是所有类的父类。比如toString（）方法，在该方法中输出了对象的基本信息，但也可以在其它类中用对其重写。
 
class Animal{
    //重写Object类的toString（）方法
    public String toString(){
        return "I am an Animal";
    }
}
public class Test {
    public static void main(String[] args) {
        Animal an = new Animal();
        System.out.println(an.toString());
    }
}
运行结果
I am an Animal
如果不对其重写会输出“类名+16进制表示的该对象哈希值”，如“Animal@b4c966a”
匿名内部类
之前都是用子类来实现接口，并根据该类进行实例化。除此之外，还可以使用匿名内部类来实现接口。
匿名内部类格式：
new 父类（参数列表）或父接口(){//匿名内部类实现部分}
 
//定义动物类接口
interface Animal{
    void shout();
}
public class Test {
    //定义静态方法animalShout（）
    public static void animalShout(Animal an){
        an.shout();
    }
    public static void main(String[] args) {
        //定义匿名内部类作为参数传递给animalShout（）方法
        animalShout(new Animal(){
            //实现shout（）方法
            public void shout(){
                System.out.println("喵喵");
            }
        });
    }
}
运行结果
喵喵
接下来分两步来编写匿名内部类（以便容易理解）：
①在new Animal()后面又一对大括号，表示创建的对象是Animal的子类实例，该子类是匿名的。
animalShout(new Animal(){});
②在大括号中编写匿名子类的实现代码。
animalShout(new Animal(){
    //实现shout（）方法
    public void shout(){
        System.out.println("喵喵");
    }
});
异常
举一个ArithmeticExceotion异常：
public class Test {
    public static void main(String[] args) {
        int result = divide(4,0);
        System.out.println("结果： "+result);
    }
    public static int divide(int x,int y){
        int result = x/y;
        return result;
    }
}
运行结果
Exception in thread "main" java.lang.ArithmeticException: / by zero
    at Test.divide(Test.java:7)
    at Test.main(Test.java:3)
Throwable类中包含两大类Error类和Exception类。
Error类称为错误类，表示Java运行时产生的系统内部错误或资源耗尽的错误，比较严重，仅靠修改程序本身是不能恢复执行的；
Exception类称为异常类，它表示程序本身可以处理的错误。
 
Throwable常用方法
方法声明
功能描述
String getMessage()
返回此throwable的详细消息字符串
void printStackTrace()
将此throwable及其追踪输出至标准错误流
void printStackTrace(PrintStream s)
将此throwable及其追踪输出到指定的输出流
 
try...catch和finally
由于发生异常，程序立即终止，无法继续执行下去，所以提供了异常的处理方式--异常捕获。异常捕获通常使用try...catch语句，格式：
try{
//程序代码块
}catch(ExceptionType(Exception类及其子类) e){
//对ExceptionType的处理
}
需要注意的是，在try代码块中，发生异常语句后面的代码不会被执行，如下面的“System.out.println(result);”没有执行。
public class Test {
    public static void main(String[] args) {
        //下面的代码定义了一个try...catch语句用于捕获异常
        try{
            int result = divide(4,0);
           //发生异常，下面这条语句没被执行
            System.out.println("结果： "+result);
        }catch (Exception e){   //对异常进行处理
            System.out.println("捕获的异常信息为："+e.getMessage());
        }
    }
    public static int divide(int x,int y){
        int result = x/y;
        return result;
    }
}
运行结果
捕获的异常信息为：/ by zero
还有finally代码块，无论是否发生异常后面代码都会被执行。由于这种特性，在程序设计时，经常会在try...catch后使用finally代码块来完成必须做的事情，例如释放系统资源。
public class Test {
    public static void main(String[] args) {
        //下面的代码定义了一个try...catch语句用于捕获异常
        try{
            int result = divide(4,0);
            System.out.println("结果： "+result);
        }catch (Exception e){   //对异常进行处理
            System.out.println("捕获的异常信息为："+e.getMessage());
            return;     //用于结束当前语句
        }finally{
            System.out.println("进入finally代码块");
        }
        System.out.println("程序继续向下执行...");
    }
    public static int divide(int x,int y){
        int result = x/y;
        return result;
    }
}
运行结果
捕获的异常信息为：/ by zero
进入finally代码块
return语句用于结束当前语句，所以“System.out.println("程序继续向下执行...");”就不会执行了，而finally中的代码仍然会执行。总的来说就是不会被return语句和异常影响。
注：当在try...catch中执行了System.exit(0)语句finally中的代码就不会执行了，System.exit(0)语句表示退出当前的Java虚拟机，任何代码都不会被执行了。还有一种是try代码块中没有代码运行finally也不会被运行。
throws关键字
在方法的后面使用throws关键字对外声明该方法有可能发生异常。格式：
修饰符 返回值类型 方法名（[参数1，参数2...]）throws  ExceptionType1[,ExceptionType2...]{}
如果在某方法上声明抛出异常，就必须使用try...catch对该方法进行处理，否则会报错。
public class Test {
    public static void main(String[] args) {
        //下面的代码定义了一个try...catch语句用于捕获异常
        try{
            int result = divide(4,2);
            System.out.println("结果： "+result);
        }catch (Exception e){   //对异常进行处理
            e.printStackTrace();   //打印捕获的异常信息
        }
    }
    //下面的方法实现了两个数相除，并使用throws关键字声明抛出异常
    public static int divide(int x,int y)throws Exception{
        int result = x/y;
        return result;
    }
}
运行结果
结果： 2
使用throws关键字声明抛出异常后，即使不会出现被0除的现象，但如果不用try...catch编译程序依然会报错。
自定义异常
在程序开发时，有可能会用到一些自己描述的特殊的异常情况，Java中允许用户自定义异常，但自定义的异常类必须继承自Exception或其子类。
自定义了异常，就需要用到throw关键字，throw关键字用于在方法中声明抛出异常的实例对象。格式：
throw Exception异常对象
下面是一个当被除数是负数时抛出自定义异常的例子。
//下面自定义一个异常类继承自Exception
class DivideByMinusExpetion extends Exception{
    public DivideByMinusExpetion(){
        super();    //调用Exception无参的构造方法
    }
    public DivideByMinusExpetion(String message){
        super(message);     //调用Exception有参的构造方法
    }
}
public class Test {
    public static void main(String[] args) {
        //下面的代码定义了一个try...catch语句用于捕获异常
        try{
            int result = divide(4,-2);
            System.out.println("结果： "+result);
        }catch (DivideByMinusExpetion e){   //对异常进行处理
            System.out.println("异常信息："+e.getMessage());  //打印捕获的异常信息
        }
    }
    //下面的方法实现了两个数相除，并使用throws关键字声明抛出异常
    public static int divide(int x,int y)throws  DivideByMinusExpetion{
        if(y<0){
            //使用throw关键字声明异常对象
            throw new DivideByMinusExpetion("被除数是负数");
        }
        int result = x/y;
        return result;
    }
}
运行结果
异常信息：被除数是负数
下面是直接用Exception类，输出结果同上
public class Test {
    public static void main(String[] args) {
        try{
            System.out.println(divide(4,-2));
        }catch (Exception e){
            System.out.println("异常信息："+e.getMessage());
        }
    }
    public static int divide(int x,int y)throws Exception{
        if(y<0){
            throw new Exception("被除数是负数");
        }
        return x/y;
    }
}
包
Java中的包是专门用来存类的，通常功能相同的类存放在相同的包中。在声明包时，用package语句。
package cn.itcast;
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}
运行结果
Hello World!
import语句
使用import语句导包。
如果两个类不在同一目录下，引用某个类时需要用import导包，格式：
import 包名.类名;
例如：import cn.itcast.Student;然后在实例化对象的时候就可以直接用Student s = new Student(); ,但如果没有导包，实例化对象时需指明位置，就得写成cn.itcast.Student s = new cn.itcast.Student(); 。
访问控制
Java中，针对类、成员方法和属性提供了四种访问级别，访问控制级别由小到大：private,default,protected,public。
  • private（类访问级别）：如果类成员被其修饰，该成员只能被该类的其他成员访问。
  • default（包访问级别）：如果一个类或者类的成员不使用任何访问控制修饰符修饰，则称则称它为默认访问控制级别，这个类或者类的成员只能被本包中的其他类访问。
  • protected（子类访问级别）：如果类成员被其修饰，该成员既能被同一包下的其他类访问，也能被不同包下的子类访问。
  • public（公共访问级别）：如果一个类或者类成员被其修饰，不管访问类与被访问类在不在同一个包中，都能被访问。
注：private和protected不能修饰类，只能修饰类成员。
 

Java学习笔记（面向对象下）的更多相关文章

  1. 0025 Java学习笔记-面向对象-final修饰符、不可变类

    final关键字可以用于何处 修饰类:该类不可被继承 修饰变量:该变量一经初始化就不能被重新赋值,即使该值跟初始化的值相同或者指向同一个对象,也不可以 类变量: 实例变量: 形参: 注意可以修饰形参 ...

  2. 0030 Java学习笔记-面向对象-垃圾回收、(强、软、弱、虚)引用

    垃圾回收特点 垃圾:程序运行过程中,会为对象.数组等分配内存,运行过程中或结束后,这些对象可能就没用了,没有变量再指向它们,这时候,它们就成了垃圾,等着垃圾回收程序的回收再利用 Java的垃圾回收机制 ...

  3. 0028 Java学习笔记-面向对象-Lambda表达式

    匿名内部类与Lambda表达式示例 下面代码来源于:0027 Java学习笔记-面向对象-(非静态.静态.局部.匿名)内部类 package testpack; public class Test1{ ...

  4. 0013 Java学习笔记-面向对象-static、静态变量、静态方法、静态块、单例类

    static可以修饰哪些成员 成员变量---可以修饰 构造方法---不可以 方法---可以修饰 初始化块---可以修饰 内部类(包括接口.枚举)---可以修饰 总的来说:静态成员不能访问非静态成员 静 ...

  5. 程序设计基础·Java学习笔记·面向对象（下）

    Java程序设计基础之面向对象(下) (补充了上的一些遗漏的知识,同时加入了自己的笔记的ヾ(•ω•`)o) (至于为什么分P,啊大概是为了自己查笔记方便(?)应该是("｀ 3′") ...

  6. 程序设计基础·Java学习笔记·面向对象（上）

    Java程序设计基础之面向对象(上) (自适应学习进度而进行记录的笔记,希望有一些小小的用处吧(^∀^●)ﾉｼ) (新人上路,望多指教,如有错误,望指正,万分感谢(oﾟvﾟ)ノ) 目录 一.面向对象 ...

  7. 0021 Java学习笔记-面向对象-包、构造器

    封装 面向对象的三大特征: 封装 继承 多态 封装: 将对象的状态信息隐藏,不允许外部程序直接访问 通过该类提供的方法来访问和操作 有啥用: 隐藏类的实现细节 在方法中加入控制逻辑,限制对成员变量的不 ...

  8. 0019 Java学习笔记-面向对象-方法

    方法属于谁 方法要么属于类,要么属于对象 static修饰的方法属于类 没有static修饰的方法属于对象 方法只能定义在类里面,不能独立定义 不能独立的执行方法,要么通过类调用,要么通过方法调用 一 ...

  9. 0018 Java学习笔记-面向对象-类的基本要素

    类与对象 大街上一个个的人,就是一个个对象 类是对一群对象的抽象,比如人都有性别.年龄.姓名,都会吃饭.睡觉等.姓名性别可以抽象为变量,吃饭睡觉可以抽象为方法,像下面一样定义个类来形容人 public ...

  10. Java学习笔记——Linux下安装配置tomcat

    朝辞白帝彩云间,千里江陵一日还. 两岸猿声啼不住,轻舟已过万重山. ——早发白帝城 首先需要安装配置JDK,这里简单回顾下.Linux下用root身份在/opt/文件夹下创建jvm文件夹,然后使用ta ...

随机推荐

  1. Python 基础之socket编程（一）

    Python 基础之socket编程(一) 可以进行通信玩儿了,感觉不错不错,网络通信就像打电话,我说一句你听一句之后,你再说一句,我听一句,就这样.....下去了.不扯淡了,来来来,看看今天都搞了点 ...

  2. Error response from daemon ... no space left on device docker启动容器服务报错

    docker 启动容器服务的时候,报错no space left on device 1. 检查磁盘是否用光 3.检查inode是否耗光,从截图看到是inode耗光导致出现问题: 进入到/run里面看 ...

  3. java架构之路（MQ专题）kafka集群配置和简单使用

    前面我们说了RabbitMQ和RocketMQ的安装和简单的使用,这次我们说一下Kafka的安装配置,后面我会用几个真实案例来说一下MQ的真实使用场景.天冷了,不愿意伸手,最近没怎么写博客了,还请见谅 ...

  4. nyoj 255-C小加 之 随机数 (map)

    255-C小加 之 随机数 内存限制:64MB 时间限制:3000ms 特判: No 通过数:15 提交数:18 难度:1 题目描述: ACM队的“C小加”同学想在学校中请一些同学一起做一项问卷调查, ...

  5. HTML5之worker开启JS多线程模式及window.postMessage跨域

    worker概述 worker基本使用 window下的postMessage worker多线程的应用 一.worker概述 web worker实际上是开启js异步执行的一种方式.在html5之前 ...

  6. 函数的prototype

    1.函数的prototype属性 每一个函数都有一个prototype属性,默认指向object空对象(原型对象),每一个原型对象都有一个constructor属性,指向函数对象 2.给原型对象添加属 ...

  7. linux 6.5操作系统建立

    VM上redhat enterprise linux6 ---> 使用仅主机模式网络连接 开始安装: ——>是否检查镜像:skip ——>选择语言: 中文/英文 ——>存储设备 ...

  8. [FPGA]Verilog实现寄存器LS374

    目录 想说的话... 正文 IC介绍 电路连接图 功能表 逻辑图 实验原理 单元实现_D触发器 整体实现(完整代码) 想说的话... 不久前正式开通了博客,以后有空了会尽量把自己学习过程中的心得或者感 ...

  9. 数据类型-Java基础一-初学者笔记

    初学者笔记 1.Java中的两种类型   在java源代码中,每个变量都必须声明一种类型(type). 有两种类型:primitive type和reference type.引用类型引用对象(ref ...

  10. C#面向对象--命名空间

    一.在C#中,使用命名空间(Namespace)可以帮助控制自定义类型的作用范围,同时对大量的类型进行组织:使用namespace关键字声明命名空间,命名空间可以嵌套使用: namespace MyN ...