yjtuuige
yjtuuige

Java 基础 05. Java 面向对象

1. 初识面向对象

  • 面向过程思想
    • 步骤清晰简单，第一步做什么，第二步做什么…
    • 面对过程适合处理一些较为简单的问题。
  • 面向对象思想
    • 物以类聚，分类 的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
    • 面向对象适合处理复杂的问题，适合处理需要多人协作的问题！
  • 对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。
  • 面向对象编程（ Object - Oriented Programming，OOP）
  • 面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据。
  • 三大特征：
    • 封装
    • 继承
    • 多态
  • 从认识的角度考虑，是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象。
  • 从代码运行角度考虑是先有类后有对象。类是对象的模板。

2. 方法回顾和加深

  • 方法的定义

    • 修饰符
    • 返回类型
    • break：跳出 switch，结束循环。return：结束方法，返回结果。
    • 方法名：注意规范，见名知意
    • 参数列表：(参数类型，参数名) …
    • 异常抛出：疑问，参考下文！
    package github.oop;
import java.io.IOException;

// 类
public class Demo01 {
    // main方法
    public static void main(String[] args) {
    }
    /*
    修饰符 返回值类型 方法名(...){
        // 方法体
        return 返回值;
    }
     */
    public String sayHello(){
        return "hello,world!";
    }
    public int max(int a,int b){
        return a>b ? a : b; // 三元运算符
    }
    // 数组下标越界：Arrayindexoutofbounds
    public void readFile(String file) throws IOException{
    }
}

  • 方法的调用

    • 静态方法（和类一起加载）
    • 非静态方法（类实例化之后，才存在）

    • 形参和实参

      package com.xxx.oop.demo01;

public class Demo03 {
  public static void main(String[] args) {
      // 实参  注意：实际参数和形式参数的类型要对应
      int add = new Demo03().add(3, 5);
      System.out.println(add);
  }
  // 形参
  public int add(int a, int b) {
      return a + b;
  }
}
      • 值传递和引用传递
      package com.xxx.oop.demo01;

// 值传递
public class Demo04 {
    public static void main(String[] args) {
        int a = 1;
        System.out.println(a);  // 1

        Demo04.change(a);
        System.out.println(a);  // 1
    }

    // 返回值为空
    public static void change(int a) {
        a = 10;
    }
}

      package com.xxx.oop.demo01;

// 引用传递：对象，本质还是值传递
public class Demo05 {
    public static void main(String[] args) {
        // 创建对象
        Person person = new Person();
        System.out.println(person.name);    // Null

        Demo05.change(person);
        System.out.println(person.name);    // 测试名
    }

    // 定义一个方法
    public static void change(Person person) {
        // person 是一个对象：指向 ---> Person person = new Person(); 这是一个具体的人，可以改变属性
        person.name = "测试名";
    }
}

// 一个类文件里可以定义多个类，但只能有一个 public 类
// 定义一个 Person 类，有一个属性：name
class Person {
    String name;
}

    • this 关键字：this 代表当前的类

3. 类与对象的关系

  • 类（模板）：是一种抽象的数据类型，它是对某一类事物整体描述/定义但是并不能代表某一个具体的事物。
  • 对象（实例）：是抽象概念的具体实例。

4. 类与对象的创建

  • 类一般包含：属性（字段 Field）、方法
// 创建类
package com.xxx.oop.demo02;

// 学生类
public class Student {
    // 属性：字段
    String name;    // 默认 Null
    int age;    // 默认 0

    // 方法
    public void study() {
        // this 代表当前的类
        System.out.println(this.name + "在学习");
    }
}
  • 使用 new 关键字创建对象。
  • 使用 new 关键字创建的时候，除了分配内存空间之外，还会给创建好的对象 进行默认的初始化，以及 对类中构造器的调用。
// 创建对象
package com.xxx.oop.demo02;

// 一个项目应该只存在一个 main 方法
public class Application {
    public static void main(String[] args) {
        // 类：抽象的，实例化
        // 类实例化后，会返回一个自己的对象！
        // student1 student2 对象，就是 Student 类的具体实例！
        Student student1 = new Student();
        Student student2 = new Student();

        // 未赋值
        System.out.println(student1.name);  // null
        System.out.println(student1.age);   // 0

        student2.name="Liu";
        student2.age=3;
        // 已赋值
        System.out.println(student2.name);  // Liu
        System.out.println(student2.age);   // 3

        student2.study();   // Liu在学习
    }
}
  • 类中的构造器也称为 构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点：
    • 必须和类的名字相同；
    • 必须没有返回类型，也不能写 void。
    • 快捷方式 Alt + Insert
  • 构造器作用：
    • 使用 new 关键字，本质在调用构造方法；
    • 用来初始化对象的值。
  • 注意：定义有参构造之后，如果想使用无参构造，必须显示的定义一个无参构造。
package com.xxx.oop.demo02;

public class Person {
    // 一个类即使什么也不写，也存在一个与类同名的方法
    // 显示的定义构造器

    String name;

    // 定义无参构造器
    /*
     * 1. 使用 new 关键字，本质在调用构造方法；
     * 2. 用来初始化对象的值
     * */
    public Person() {
        this.name = "name01";
    }

    // 有参构造器
    // 定义有参构造器，如果想使用无参构造，无参就必须显示定义
    public Person(String name) {
        this.name = name;
    }
}

package com.xxx.oop.demo02;

// 一个项目应该只存在一个 main 方法
public class Application {
    public static void main(String[] args) {
        // 实例化对象，调用无参
        Person person = new Person();
        System.out.println(person.name);

        // 调用有参
        Person person1 = new Person("有参构造");
        System.out.println(person1.name);
    }
}

5. 创建对象内存分析

  • 创建类
package com.xxx.oop.demo03;

public class Pet {
    // 属性
    public String name;
    public int age;

    // 方法
    public void shout() {
        System.out.println("叫了一声！");
    }
}
  • 创建对象（实例化类）
package com.xxx.oop;

import com.xxx.oop.demo03.Pet;

public class Application {
    public static void main(String[] args) {
        // 实例化类，创建 dog 对象
        Pet dog = new Pet();
        // 赋值
        dog.name = "旺财";
        dog.age = 3;

        System.out.println(dog.name);   // 旺财
        System.out.println(dog.age);    // 3
        dog.shout();    // 叫了一声！
        System.out.println("===========");
        // 创建 cat 对象
        Pet cat = new Pet();
        // 未赋值，为默认值
        System.out.println(cat.name);   // Null
        System.out.println(cat.age);    // 0
        cat.shout();    // 叫了一声！
    }
}

小结：

  1. 类与对象
    • 类是一个 模板：抽象；
    • 对象是一个具体的 实例。
  2. 方法
    定义，调用
  3. 对象的引用
    • 引用类型：除基本类型（8）外的类型
    • 对象是通过引用来操作的：栈--->堆
  4. 属性：字段 Field 成员变量
    • 默认初始化值：
      • 数字： 0，0.0
      • char：u0000
      • boolean：false
      • 引用：null
    • 修饰符 属性类型 属性名 = 属性值
  5. 对象的创建和使用
    • 必须使用 new 关键字创造对象，构造器 Person person1 = new Person();
    • 对象的属性 person1.name
    • 对象的方法 person1.sleep()
  6. 类：
    • 静态的属性：属性
    • 动态的行为：方法

6. 面向对象三大特性：封装、继承、多态

1、封装：属性私有，get/set

  • 程序设计要追求 高内聚，低耦合。高内聚，就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
  • 封装（数据的隐藏）：通常，应禁止直接访问一个对象中数据的实际表示，而应该通过操作接口来访问，这称为信息隐藏。
package com.xxx.oop;

import com.xxx.oop.demo04.Student;

public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();

        s1.setName("Liu");
        System.out.println(s1.getName());

        s1.setAge(999); // 非法值
        System.out.println(s1.getAge());
    }
}

package com.xxx.oop.demo04;

// 类    private：私有
public class Student {
    // 属性私有
    private String name;    // 姓名
    private int id;    // 学号
    private char sex;   // 性别
    private int age;    // 年龄

    // 提供一些可以操作属性的方法 public get() set()
    // 自动创建 get set 方法： 快捷键 Alt + Insert
    // get 获取数据
    public String getName() {
        return name;
    }
    // set 设置数据
    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age > 120 || age < 0) {
            this.age = 3;
        } else {
            this.age = age;
        }
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }
}
  • 封装的作用：
    • 提高了代码的安全性，保护数据；
    • 隐藏代码的实现细则；
    • 统一接口；
    • 系统可维护增加了。

2、继承：object 类、super、方法重写

  • 继承的本质是 对某一批类的抽象，从而实现对现实世界更好的建模。
  • extands 的意思是 扩展。子类是父类的扩展。
  • Java 中类 只有单继承，没有多继承！
  • 继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。
  • 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类使用关键字 extends 来表示。
  • 子类和父类之间从意义上讲应该具有 is a 的关系。
  • 在 Java 中，所有的类，都默认直接或间接的继承 object 类。
    • 创建父类 Person 
      package com.xxx.oop.demo05;

// Person 人 ：父类
// 在 Java 中，所有的类，都默认直接或间接的继承 object 类，显示当前类的层次结构 快捷键 Ctrl + H
public class Person {
    // public   公共
    // protected    受保护的
    // default  默认
    // private  私有
    private String s1 = "父类属性";

    public String getS1() {
        return s1;
    }

    public void setS1(String s1) {
        this.s1 = s1;
    }

    public void say() {
        System.out.println("父类方法");
    }
}
    • 创建子类 Student 
      package com.xxx.oop.demo05;
// Student 学生 is 人：派生类，子类
// 子类继承了父类，就会拥有父类的全部方法
public class Student extends Person{
    // 子类中并没有创建任何属性和方法
}
    • 测试类：通过子类调用父类的属性和方法 
      package com.xxx.oop;

import com.xxx.oop.demo05.Student;
public class Application {
    public static void main(String[] args) {
        // 实例化学生类
        Student student = new Student();
        // 打印 Person 父类的属性值
        System.out.println(student.getS1());
        // 调用 Person 父类的方法
        student.say();
    }
}
  • 显示当前类的层次结构：快捷键 Ctrl + H
  • 调用结果

Super 概述

  • 私有的（private）东西无法被继承！！！
  • 子类会默认的先调用父类的无参构造方法 (隐藏代码 super();)

super 注意点：

  1. super 调用父类的构造方法，必须在构造方法的第一行！
  2. super 必须只能出现在子类的方法或者构造方法中！
  3. super 和 this 不能同时调用构造方法！

super VS this：

  • 代表的对象不同：
    • this：本身调用者这个对象；
    • super：代表父类对象的引用；
  • 前提
    • this：没有继承也可以使用；
    • super：只能在继承条件才可以使用；
  • 构造方法
    • this（）：本类的构造；
    • super（）：父类的构造。

重写：都是方法的重写，与属性无关

  • 静态方法测试
  • 非静态方法测试

总结：重写，需要有 继承关系，子类重写父类的方法，且必须是 非静态方法！

  1. 方法名必须相同;
  2. 参数列表列表必须相同;
  3. 修饰符：范围可以扩大但不能缩小: public > Protected > Default > private
  4. 抛出的异常：范围，可以被缩小，但不能扩大；ClassNotFoundException —> Exception (大)
  • 重写：子类的方法和父类必须要一致；方法体不同！
  • 为什么需要重写：父类的功能，子类不一定需要，或者不一定满足！
  • 重写快捷键：Alt + Insert => override 或（Ctrl + O)

3、多态：

  • 即同一方法可以根据发送对象的不同，而采用多种不同的行为方式。
  • 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多（父类，有关系的类）。
  • 多态存在的条件：
    • 有继承关系；
    • 子类重写父类方法；
    • 父类引用指向子类对象。
  • 多态注意事项：
    1. 多态是 方法的多态，属性没有多态；
    2. 父类和子类，有联系，类型转换异常！ClassCastException!
    3. 存在条件：继承条件，方法需要重写！父类引用指向子类对象！Father f1 = new Son();
  • 不可重写的方法（无法多态）：
    1. static 方法，（静态）属于类，它不属于实例;
    2. final 常量；
    3. private 方法；（私有）

instanceof：判断两个类型之间是否存在父子关系。左边的对象，是否是右边的类的实例，返回 boolean 的数据类型。

Object > String
Object > Person > Teacher
Object > Person > Student
  • 创建 Person 类（父类）：
package com.xxx.oop.demo09;
// 父类
public class Person {
    public void go(){
        System.out.println("go");
    }
}
  • 创建子类：Teacher 类继承 Person 类：
package com.xxx.oop.demo09;
// 子类，继承 Person 类
public class Teacher extends Person{
}
  • 创建子类：Student 类继承 Person 类：
package com.xxx.oop.demo09;
// 子类，继承 Person 类
public class Student extends Person{
}
  • 主函数
public static void main(String[] args) {
        Object obj = new Student();
        System.out.println(obj instanceof Student); // true
        System.out.println(obj instanceof Person);  // true
        System.out.println(obj instanceof Object);  // true
        System.out.println(obj instanceof Teacher); // false
        System.out.println(obj instanceof String);  // false
    }
  • 运行结果
  • 主函数
Person person = new Student();
System.out.println(person instanceof Student); // true
System.out.println(person instanceof Person);  // true
System.out.println(person instanceof Object);  // true
System.out.println(person instanceof Teacher); // false
// System.out.println(person instanceof String);  // 编译报错
  • 运行结果
  • 主函数
Student student = new Student();
System.out.println(student instanceof Student); // true
System.out.println(student instanceof Person);  // true
System.out.println(student instanceof Object);  // true
// System.out.println(student instanceof Teacher); // 编译报错
// System.out.println(student instanceof String);  // 编译报错
  • 运行结果
  • 类型转换：父类型转子类型（高转低），需强制转换；子类型转父类型（低转高），可能会丢失方法。
  • 创建父类 Person
package com.xxx.oop.demo09;
// 父类
public class Person {
    public void run(){
        System.out.println("run");
    }
}
  • 创建子类 Student，继承 Person 类
package com.xxx.oop.demo09;
// 子类，继承 Person 类
public class Student extends Person{
    public void go(){
        System.out.println("go");
    }
}
  • 主函数类：
package com.xxx.oop;

import com.xxx.oop.demo09.Person;
import com.xxx.oop.demo09.Student;

// 测试类
public class Application {
    public static void main(String[] args) {
        // 类型之间转换：父类 子类
        // 高                低
        Person person = new Student();  // 低转高，自动转换
        // person.go(); 无法调用 Student 子类的独有方法

        // 将 person 强制转化成 Student 类型，就可以使用 Student 类型的方法了
        Student student = (Student) person; // 高转低，强制转换
        student.go();   // 调用 Student 子类的独有方法
        // ((Student) person).go(); 简写方式
        student.run();  // 调用 Person 父类的方法
    }
}
  • 运行结果
  • 低转高
public class Application {
    public static void main(String[] args) {
        // 类型之间转换：父类 子类
        Student student = new Student();
        student.go();
        // 子类转换为父类，可能会丢失自己的本来方法
        Person person = student;    // 低转高，自动转换
    }
}

类型转换 总结：

  1. 父类引用指向子类的对象
  2. 把子类转换为父类，向上转换
  3. 把父类转换为子类，向下转换，强制转换
  4. 方便方法的调用，减少重复的代码

static 关键字

  • 修饰属性时为静态属性：private static int age; 
package com.xxx.oop.demo10;
// static
public class Student {
    private static int age; // 静态变量（类变量）
    private double score;   // 非静态变量

    public static void main(String[] args) {
        Student s1 = new Student();
        // 通过对象方式调用 静态变量
        System.out.println(s1.age); // 0
        // 通过对象方式调用 非静态变量
        System.out.println(s1.score);   // 0.0
        // 通过类方式调用 静态变量
        System.out.println(Student.age);    // 0
        // 报错：通过类方式无法调用 非静态变量
        // System.out.println(Student.score);   // 编译报错
    }
}
  • 修饰方法时为静态方法：public static void go(){...}
    • 静态方法调用：
      1. 直接调用 go();
      2. 通过类方式调用 Student.go();
      3. 通过对象实例的方式调用 new Student().go();
    • 非静态方法调用：只能通过对象实例的方式，来调用 new Student().run(); 
package com.xxx.oop.demo10;
// static
public class Student {
    public void run(){      // 非静态方法
        go();   // 非静态方法中可以直接调用静态方法
        System.out.println("非静态方法");
    }
    public static void go(){    // 静态方法
        System.out.println("静态方法");
    }
    public static void main(String[] args) {
        // 静态方法调用
        go();   // 1. 直接调用
        Student.go();   // 2. 通过类方式
        new Student().go(); // 3. 通过对象实例方式
        // 非静态方法调用
        // run();  报错：不能直接调用非静态方法
        new Student().run();    // 只能通过对象方式调用 非静态方法
    }
}

补充

  • 匿名代码块：{ // 代码体 }
  • 静态代码块：static { // 代码体 } 
package com.xxx.oop.demo10;

public class Person {
    // 2. 匿名代码块：赋初始值
    {
        System.out.println("匿名代码块");
    }
    // 1. 静态代码块：只加载一次
    static {
        System.out.println("静态代码块");
    }
    // 3. 构造方法
    public Person() {
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person person = new Person();
        System.out.println("======================");
        Person person1 = new Person();
    }
}
  • 执行顺序：静态代码块 --> 匿名代码块 --> 构造方法
    静态代码块只会执行一次。
  • static 静态导入包
package com.xxx.oop.demo10;
// 静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;
public class Test {
    public static void main(String[] args) {
        System.out.println(random());   // 导入后直接调用
        System.out.println(PI);   // 导入后直接调用
    }
}

7. 抽象类和接口

抽象类

  • abstract 修饰符可以用来修饰方法，也可以修饰类，如果修饰方法，那么该方法就是抽象方法，如果修饰类那么该类，就是抽象类。
  • 抽象类中可以没有抽象方法，但是 有抽象方法的类，一定要声明为抽象类。
  • 抽象类，不能使用 new 关键字，来创建对象，它是 用来让子类继承的。
  • 抽象方法只有方法的声明，没有方法的实现。它是 用来让子类实现的。
  • 子类继承抽象类，就必须要实现抽象类，没有实现的抽象方法，否则该子类也要声明为抽象类。
  • 创建抽象类：
package com.xxx.oop.demo11;

// abstract 抽象类： 类继承 extends 单继承 （接口可以实现多继承）
public abstract class Action {
    // 约束，有人帮我们实现
    // abstract 抽象方法，只有方法名，没有方法的实现
    public abstract void doSomething();
    // 抽象类中可以存在普通的方法
    public void run(){
        System.out.println("抽象类中的普通方法");
    }
}
  • 抽象类的子类：必须实现父类的方法（重写），除非子类也是抽象类
package com.xxx.oop.demo11;

// 抽象类的所有方法，继承它的子类都必须实现它的方法（重写），除非子类也是抽象类
public class A extends Action{
    // 重写父类的抽象方法
    @Override
    public void doSomething() {
    }
}
  • 抽象类的特点：
    1. 不能 new 这个抽象类，只能依靠子类去实现；约束！！
    2. 抽象类中可以写普通方法；
    3. 抽象方法必须在抽象类中。

接口

  • 普通类：只有具体实现；
  • 抽象类：具体实现和规范（抽象方法）都有！
  • 接口：只有规范！无法自己写方法 （专业的约束，约束和实现分离：面向接口编程）
  • 接口就是规范，定义的是一组规则，体现了现实世界中 如果你是…则必须能… 的思想。如果你是天使，则必须能飞。如果你是汽车，则必须能跑。如果你好人，则必须干掉坏人；如果你是坏人，则必须欺负好人。
  • 接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守。
  • OO 的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如 c++、java、c# 等），就是因为设计模式所硏究的，实际上就是如何合理的去抽象。
  • 声明类的关键字是 class，声明接口的关键字是 interface。
  • 创建 UserService 接口：interface 
package com.xxx.oop.demo12;

// interface 接口定义关键字 接口都需要有实现类
public interface UserService {
    // 常量（一般不这样用）：默认：public static final
    int AGE=99;

    // 接口中的定义的方法都是抽象的，默认： public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}
  • 创建 TimeService 接口
package com.xxx.oop.demo12;

public interface TimeService {
    void timer();
}
  • 创建实现 UserService,TimeService 两个接口的类（多继承）
package com.xxx.oop.demo12;
// 类实现接口 interface
// 实现了接口的类，就必须实现接口中的方法 快捷键：Ctrl + I
// 通过接口实现多继承 UserService,TimeService
public class UserServiceImpl implements UserService,TimeService{
    @Override
    public void add(String name) {
    }
    @Override
    public void delete(String name) {
    }
    @Override
    public void update(String name) {
    }
    @Override
    public void query(String name) {
    }
    @Override
    public void timer() {
    }
}

接口总结：

  • 约束，规范
  • 定义一些方法，让不同的人实现
  • 接口方法（默认）：public abstract
  • 接口常量（默认）：public static final
  • 接口不能被实例化，因为接口中没有构造方法
  • 类通过 implements 可以实现多个接口（多继承）
  • 实现接口的类，必须要重写接口中的方法
  • 实现接口的类名称：一般是在接口名后面加 Impl，如：接口UserService，实现类 UserServiceImpl
  • 接口方法重写：快捷键：Ctrl + I

8. 内部类及 OOP 实战

  • 内部类就是在一个类的内部，再定义一个类。比如，A 类中定义一个 B 类，那么 B 类相对 A 类来说就称为内部类，而 A 类相对 B 类来说就是外部类了。

    1. 成员内部类
    package com.xxx.oop.demo13;

// 外部类
public class Outer {
    private int id = 10;

    public void out() {
        System.out.println("外部类方法");
    }

    // 内部类
    public class Inner {
        // 内部方法
        public void in() {
            System.out.println("内部类方法");
        }
        // 内部方法，获取外部类私有属性
        public void getId(){
            System.out.println(id);
        }
        public void getOut(){
            // 调用外部方法
            out();
        }
    }
}

    package com.xxx.oop;

import com.xxx.oop.demo13.Outer;

// 测试类
public class Application {
    public static void main(String[] args) {
        // 外部类实例
        Outer outer = new Outer();
        // 通过外部类实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getId();
        inner.getOut();
    }
}

    1. 静态内部类：无法直接访问外部类非静态属性和方法，需要通过外部类的实例来访问

      package com.xxx.oop.demo13;

// 外部类
public class Outer {
    private int id;

    public void out() {
        System.out.println("外部类方法");
    }

    // 静态内部类
    public static class Inner {
        // 内部方法
        public void in() {
            System.out.println("内部类方法");
        }
    }
}

    2. 局部内部类：外部类方法中创建

      package com.xxx.oop.demo13;

// 外部类
public class Outer {
   public void method(){
       // 局部内部类
       class Inner{
           public void in(){
               System.out.println("局部内部类");
           }
       }
   }
}

    3. 匿名内部类

      package com.xxx.oop.demo13;

public class Test {
    public static void main(String[] args) {
        // 匿名内部类：没有名字初始化类，不用将实例保存到变量中
        new Apple().eat();

        // 默认会返回 UserService userService
        new UserService() {
            // 重写接口的方法
            @Override
            public void hello() {
                System.out.println("重写接口方法");
            }
        };
    }
}

class Apple {
    public void eat() {
        System.out.println("1");
    }
}

interface UserService{
    void hello();
}

你可能感兴趣的:(Java 基础 05. Java 面向对象)

  • c++ 的iostream 和 c++的stdio的区别和联系 黄卷青灯77 c++算法开发语言iostreamstdio
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
  • Long类型前后端数据不一致 igotyback 前端
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
  • LocalDateTime 转 String igotyback java开发语言
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
  • 如何在 Fork 的 GitHub 项目中保留自己的修改并同步上游更新？github_fork_update iBaoxing github
    如何在Fork的GitHub项目中保留自己的修改并同步上游更新？在GitHub上Fork了一个项目后，你可能会对项目进行一些修改，同时原作者也在不断更新。如果想要在保留自己修改的基础上，同步原作者的最新更新，很多人会不知所措。本文将详细讲解如何在不丢失自己改动的情况下，将上游仓库的更新合并到自己的仓库中。问题描述假设你在GitHub上Fork了一个项目，并基于该项目做了一些修改，随后你发现原作者对
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数 广龙宇 一起学Rust#Rust设计模式rust设计模式开发语言
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
  • Python教程：一文了解使用Python处理XPath 旦莫 Python进阶python开发语言
    目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
  • 四章-32-点要素的聚合 彩云飘过
    本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计 网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java算法华为javascript
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
  • 高端密码学院笔记285 柚子_b4b4
    高端幸福密码学院（高级班）幸福使者：李华第（598）期《幸福》之回归内在深层生命原动力基础篇——揭秘“激励”成长的喜悦心理案例分析主讲：刘莉一，知识扩充:成功=艰苦劳动+正确方法+少说空话。贪图省力的船夫，目标永远下游。智者的梦再美，也不如愚人实干的脚印。幸福早课堂2020.10.16星期五一笔记:1，重视和珍惜的前提是知道它的价值非常重要，当你珍惜了，你就真正定下来，真正的学到身上。2，大家需要
  • 从0到500+，我是如何利用自媒体赚钱？ 一列脚印
    运营公众号半个多月，从零基础的小白到现在慢慢懂了一些运营的知识。做好公众号是很不容易的，要做很多事情；排版、码字、引流…通通需要自己解决，业余时间全都花费在这上面涨这么多粉丝是真的不容易，对比知乎大佬来说，我们这种没资源，没人脉，还没钱的小透明来说，想要一个月涨粉上万，怕是今天没睡醒（不过你有的方法，算我piapia打脸）至少我是清醒的，自己慢慢努力，实现我的万粉目标！大家快来围观、支持我吧！孩子
  • 数组去重 好奇的猫猫猫
    整理自js中基础数据结构数组去重问题思考？如何去除数组中重复的项例如数组：[1,3,4,3,5]我们在做去重的时候，一开始想到的肯定是，逐个比较，外面一层循环，内层后一个与前一个一比较，如果是久不将当前这一项放进新的数组，挨个比较完之后返回一个新的去过重复的数组不好的实践方式上述方法效率极低，代码量还多，思考？有没有更好的方法这时候不禁一想当然有了！！！hashtable啊，通过对象的hash办法
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业javascripthtmlcss旅游风景
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动 二挡起步 web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
  • Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Pythonpython开发语言大数据数据分析数据挖掘
    大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
  • 大伟说成语之唉声叹气 求索大伟
    ＊大伟说成语＊【唉声叹气】叹气：因心里不痛快或不如意而吐出长气，发出声音。因为痛苦、憋闷或感伤而发出叹息的声音。【大伟说】情绪外露，非人类所特有，动物亦有情绪，悲哀和欢乐所表示的情绪亦是不一样的，会嗷嗷大叫也会低吟痛哭。不同的是，人类的情绪更复杂，更多样，更丰富。唉声叹气，可以说是最基础的情绪，因为无奈而举足无措，不知该如何如何化解，只有独自一人慢慢承受，长吁短叹不知如何是好，其实是无能无力的表现
  • Python快速入门 —— 第三节：类与对象 孤华暗香 Python快速入门python开发语言
    第三节：类与对象目标：了解面向对象编程的基础概念，并学会如何定义类和创建对象。内容：类与对象：定义类：class关键字。类的构造函数：__init__()。类的属性和方法。对象的创建与使用。示例：classStudent:def__init__(self,name,age,major):self.name&#
  • MongoDB Oplog 窗口 喝醉酒的小白 MongoDB运维
    在MongoDB中，oplog（操作日志）是一个特殊的日志系统，用于记录对数据库的所有写操作。oplog允许副本集成员（通常是从节点）应用主节点上已经执行的操作，从而保持数据的一致性。它是MongoDB副本集实现数据复制的基础。MongoDBOplog窗口oplog窗口是指在MongoDB副本集中，从节点可以用来同步数据的时间范围。这个窗口通常由以下因素决定：Oplog大小：oplog的大小是有限
  • node.js学习 小猿L node.jsnode.js学习vim
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
  • 数据仓库——维度表一致性 墨染丶eye 背诵数据仓库
    数据仓库基础笔记思维导图已经整理完毕，完整连接为：数据仓库基础知识笔记思维导图维度一致性问题从逻辑层面来看，当一系列星型模型共享一组公共维度时，所涉及的维度称为一致性维度。当维度表存在不一致时，短期的成功难以弥补长期的错误。维度时确保不同过程中信息集成起来实现横向钻取货活动的关键。造成横向钻取失败的原因维度结构的差别，因为维度的差别，分析工作涉及的领域从简单到复杂，但是都是通过复杂的报表来弥补设计
  • 高级 ECharts 技巧：自定义图表主题与样式 SnowMan1993 echarts信息可视化数据分析
    ECharts是一个强大的数据可视化库，提供了多种内置主题和样式，但你也可以根据项目的设计需求，自定义图表的主题与样式。本文将介绍如何使用ECharts自定义图表主题，以提升数据可视化的吸引力和一致性。1.什么是ECharts主题？ECharts的主题是指定义图表样式的配置项，包括颜色、字体、线条样式等。通过预设主题，你可以快速更改图表的整体风格，而自定义主题则允许你在此基础上进行个性化设置。2.
  • 01-Git初识 Meereen Gitgit
    01-Git初识概念：一个免费开源，分布式的代码版本控制系统，帮助开发团队维护代码作用：记录代码内容。切换代码版本，多人开发时高效合并代码内容如何学：个人本机使用：Git基础命令和概念多人共享使用：团队开发同一个项目的代码版本管理Git配置用户信息配置：用户名和邮箱，应用在每次提交代码版本时表明自己的身份命令：查看git版本号git-v配置用户名gitconfig--globaluser.name
  • ARM驱动学习之基础小知识 JT灬新一 ARM嵌入式arm开发学习
    ARM驱动学习之基础小知识•sch原理图工程师工作内容–方案–元器件选型–采购（能不能买到，价格）–原理图（涉及到稳定性）•layout画板工程师–layout（封装、布局，布线，log）（涉及到稳定性）–焊接的一部分工作（调试阶段板子的焊接）•驱动工程师–驱动，原理图，layout三部分的交集容易发生矛盾•PCB研发流程介绍–方案，原理图(网表)–layout工程师（gerber文件）–PCB板
  • Rust基础知识 GRKF15 rust开发语言后端
    1.Rust语言简介1.1基础语法变量声明：let关键字用于声明变量，可以指定或不指定类型，如leta=10;和letmutc=30i32;。函数定义：使用fn关键字定义函数，并指定参数类型及返回类型，如fnadd(i:i32,j:i32)->i32{i+j}。控制流：包括if、else等，控制语句后需要使用;来结束语句。1.2数据类型整数类型：i8、i16、i32、i64、i128，以及无符号的
  • 18、架构-可观测性之聚合度量 大树~~ 架构javapython后端架构
    聚合度量聚合度量是指对系统运行时产生的各种指标数据进行收集、聚合和分析，以了解系统的健康状况和性能表现。聚合度量是可观测性的关键组成部分，通过对度量数据的分析，可以及时发现系统中的异常和瓶颈。以下是对聚合度量各个方面的详细解析，并结合具体的数据案例和技术支撑。指标收集收集系统运行时产生的各种指标数据是聚合度量的基础。常见的指标包括CPU使用率、内存使用率、请求处理时间、请求数、错误率等。以下是指标
  • Python开发常用的三方模块如下： 换个网名有点难 python开发语言
    Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
  • ExpRe[25] bash外的其它shell：zsh和fish tritone ExpRebashlinuxubuntushell
    文章目录zsh基础配置实用特性插件`autojump`语法高亮自动补全fish优点缺点时效性本篇撰写时间为2021.12.15，由于计算机技术日新月异，博客中所有内容都有时效和版本限制，具体做法不一定总行得通，链接可能改动失效，各种软件的用法可能有修改。但是其中透露的思想往往是值得学习的。本篇前置：ExpRe[10]Ubuntu[2]准备神秘软件、备份恢复软件https://www.cnblogs
  • Java 重写(Override)与重载(Overload) 叨唧唧的
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
  • 网络编程基础 记得开心一点啊 网络
    目录♫什么是网络编程♫Socket套接字♪什么是Socket套接字♪数据报套接字♪流套接字♫数据报套接字通信模型♪数据报套接字通讯模型♪DatagramSocket♪DatagramPacket♪实现UDP的服务端代码♪实现UDP的客户端代码♫流套接字通信模型♪流套接字通讯模型♪ServerSocket♪Socket♪实现TCP的服务端代码♪实现TCP的客户端代码♫什么是网络编程网络编程，指网络上
  • 多线程编程之存钱与取钱 周凡杨 javathread多线程存钱取钱
      生活费问题是这样的：学生每月都需要生活费，家长一次预存一段时间的生活费，家长和学生使用统一的一个帐号，在学生每次取帐号中一部分钱，直到帐号中没钱时 通知家长存钱，而家长看到帐户还有钱则不存钱，直到帐户没钱时才存钱。   问题分析：首先问题中有三个实体，学生、家长、银行账户，所以设计程序时就要设计三个类。其中银行账户只有一个，学生和家长操作的是同一个银行账户，学生的行为是
  • java中数组与List相互转换的方法 征客丶 JavaScriptjavajsonp
    1.List转换成为数组。（这里的List是实体是ArrayList) 　　调用ArrayList的toArray方法。 　　toArray 　　public T[] toArray(T[] a)返回一个按照正确的顺序包含此列表中所有元素的数组；返回数组的运行时类型就是指定数组的运行时类型。如果列表能放入指定的数组，则返回放入此列表元素的数组。否则，将根据指定数组的运行时类型和此列表的大小分
  • Shell 流程控制 daizj 流程控制if elsewhilecaseshell
    Shell 流程控制 和Java、PHP等语言不一样，sh的流程控制不可为空，如(以下为PHP流程控制写法)： <?php if(isset($_GET["q"])){ search(q);}else{// 不做任何事情} 在sh/bash里可不能这么写，如果else分支没有语句执行，就不要写这个else，就像这样 if else if if 语句语
  • Linux服务器新手操作之二 周凡杨 Linux 简单 操作
    1.利用关键字搜寻Man Pages    man -k keyword  其中-k 是选项，keyword是要搜寻的关键字 如果现在想使用whoami命令，但是只记住了前3个字符who，就可以使用 man -k who来搜寻关键字who的man命令       [haself@HA5-DZ26 ~]$ man -k
  • socket聊天室之服务器搭建 朱辉辉33 socket
    因为我们做的是聊天室，所以会有多个客户端，每个客户端我们用一个线程去实现，通过搭建一个服务器来实现从每个客户端来读取信息和发送信息。    我们先写客户端的线程。 public class ChatSocket extends Thread{ Socket socket; public ChatSocket(Socket socket){ this.sock
  • 利用finereport建设保险公司决策分析系统的思路和方法 老A不折腾 finereport金融保险分析系统报表系统项目开发
    决策分析系统呈现的是数据页面，也就是俗称的报表，报表与报表间、数据与数据间都按照一定的逻辑设定，是业务人员查看、分析数据的平台，更是辅助领导们运营决策的平台。底层数据决定上层分析，所以建设决策分析系统一般包括数据层处理（数据仓库建设）。   项目背景介绍 通常，保险公司信息化程度很高，基本上都有业务处理系统（像集团业务处理系统、老业务处理系统、个人代理人系统等）、数据服务系统（通过
  • 始终要页面在ifream的最顶层 林鹤霄
    index.jsp中有ifream，但是session消失后要让login.jsp始终显示到ifream的最顶层。。。始终没搞定，后来反复琢磨之后，得到了解决办法，在这儿给大家分享下。。 index.jsp--->主要是加了颜色的那一句 <html> <iframe name="top" ></iframe> <ifram
  • MySQL binlog恢复数据 aigo mysql
    1，先确保my.ini已经配置了binlog：   # binlog log_bin = D:/mysql-5.6.21-winx64/log/binlog/mysql-bin.log log_bin_index = D:/mysql-5.6.21-winx64/log/binlog/mysql-bin.index log_error = D:/mysql-5.6.21-win
  • OCX打成CBA包并实现自动安装与自动升级 alxw4616 ocxcab
    近来手上有个项目,需要使用ocx控件 (ocx是什么? http://baike.baidu.com/view/393671.htm) 在生产过程中我遇到了如下问题. 1. 如何让 ocx 自动安装?     a) 如何签名?     b) 如何打包?     c) 如何安装到指定目录? 2.
  • Hashmap队列和PriorityQueue队列的应用 百合不是茶 Hashmap队列PriorityQueue队列
      HashMap队列已经是学过了的,但是最近在用的时候不是很熟悉,刚刚重新看以一次,   HashMap是K,v键 ,值     put()添加元素      //下面试HashMap去掉重复的 package com.hashMapandPriorityQueue; import java.util.H
  • JDK1.5 returnvalue实例 bijian1013 javathreadjava多线程returnvalue
    Callable接口： 返回结果并且可能抛出异常的任务。实现者定义了一个不带任何参数的叫做 call 的方法。 Callable 接口类似于 Runnable，两者都是为那些其实例可能被另一个线程执行的类设计的。但是 Runnable 不会返回结果，并且无法抛出经过检查的异常。        ExecutorService接口方
  • angularjs指令中动态编译的方法(适用于有异步请求的情况) 内嵌指令无效 bijian1013 JavaScriptAngularJS
            在directive的link中有一个$http请求，当请求完成后根据返回的值动态做element.append('......');这个操作，能显示没问题，可问题是我动态组的HTML里面有ng-click，发现显示出来的内容根本不执行ng-click绑定的方法！     
  • 【Java范型二】Java范型详解之extend限定范型参数的类型 bit1129 extend
    在第一篇中，定义范型类时，使用如下的方式：   public class Generics<M, S, N> { //M,S,N是范型参数 }  这种方式定义的范型类有两个基本的问题：   1. 范型参数定义的实例字段，如private M m = null;由于M的类型在运行时才能确定，那么我们在类的方法中，无法使用m，这跟定义pri
  • 【HBase十三】HBase知识点总结 bit1129 hbase
    1. 数据从MemStore flush到磁盘的触发条件有哪些？    a.显式调用flush，比如flush 'mytable'    b.MemStore中的数据容量超过flush的指定容量，hbase.hregion.memstore.flush.size,默认值是64M 2. Region的构成是怎么样？ 1个Region由若干个Store组成
  • 服务器被DDOS攻击防御的SHELL脚本 ronin47
    mkdir /root/bin vi /root/bin/dropip.sh #!/bin/bash/bin/netstat -na|grep ESTABLISHED|awk ‘{print $5}’|awk -F:‘{print $1}’|sort|uniq -c|sort -rn|head -10|grep -v -E ’192.168|127.0′|awk ‘{if($2!=null&a
  • java程序员生存手册-craps 游戏-一个简单的游戏 bylijinnan java
    import java.util.Random; public class CrapsGame { /** * *一个简单的赌*博游戏，游戏规则如下： *玩家掷两个骰子，点数为1到6，如果第一次点数和为7或11，则玩家胜， *如果点数和为2、3或12，则玩家输， *如果和为其它点数，则记录第一次的点数和，然后继续掷骰，直至点数和等于第一次掷出的点
  • TOMCAT启动提示NB: JAVA_HOME should point to a JDK not a JRE解决 开窍的石头 JAVA_HOME
    当tomcat是解压的时候，用eclipse启动正常，点击startup.bat的时候启动报错; 报错如下：   The JAVA_HOME environment variable is not defined correctly This environment variable is needed to run this program NB: JAVA_HOME shou
  • [操作系统内核]操作系统与互联网 comsci 操作系统
         我首先申明：我这里所说的问题并不是针对哪个厂商的，仅仅是描述我对操作系统技术的一些看法       操作系统是一种与硬件层关系非常密切的系统软件，按理说，这种系统软件应该是由设计CPU和硬件板卡的厂商开发的，和软件公司没有直接的关系，也就是说，操作系统应该由做硬件的厂商来设计和开发
  • 富文本框ckeditor_4.4.7 文本框的简单使用 支持IE11 cuityang 富文本框
    <html xmlns="http://www.w3.org/1999/xhtml"> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /> <title>知识库内容编辑</tit
  • Property null not found darrenzhu datagridFlexAdvancedpropery null
    When you got error message like "Property null not found ***", try to fix it by the following way: 1)if you are using AdvancedDatagrid, make sure you only update the data in the data prov
  • MySQl数据库字符串替换函数使用 dcj3sjt126com mysql函数替换
    需求：需要将数据表中一个字段的值里面的所有的  .   替换成  _   原来的数据是  site.title  site.keywords  .... 替换后要为     site_title  site_keywords   使用的SQL语句如下：   updat
  • mac上终端起动MySQL的方法 dcj3sjt126com mysqlmac
    首先去官网下载: http://www.mysql.com/downloads/ 我下载了5.6.11的dmg然后安装,安装完成之后..如果要用终端去玩SQL.那么一开始要输入很长的:/usr/local/mysql/bin/mysql 这不方便啊,好想像windows下的cmd里面一样输入mysql -uroot -p1这样...上网查了下..可以实现滴. 打开终端,输入: 1
  • Gson使用一（Gson） eksliang jsongson
    转载请出自出处：http://eksliang.iteye.com/blog/2175401 一.概述 从结构上看Json，所有的数据（data）最终都可以分解成三种类型： 第一种类型是标量（scalar），也就是一个单独的字符串（string）或数字（numbers），比如"ickes"这个字符串。 第二种类型是序列（sequence），又叫做数组（array）
  • android点滴4 gundumw100 android
    Android 47个小知识 http://www.open-open.com/lib/view/open1422676091314.html Android实用代码七段（一） http://www.cnblogs.com/over140/archive/2012/09/26/2611999.html http://www.cnblogs.com/over140/arch
  • JavaWeb之JSP基本语法 ihuning javaweb
      目录   JSP模版元素  JSP表达式  JSP脚本片断  EL表达式  JSP注释  特殊字符序列的转义处理  如何查找JSP页面中的错误   JSP模版元素    JSP页面中的静态HTML内容称之为JSP模版元素，在静态的HTML内容之中可以嵌套JSP
  • App Extension编程指南（iOS8/OS X v10.10）中文版 啸笑天 ext
             当iOS 8.0和OS X v10.10发布后，一个全新的概念出现在我们眼前，那就是应用扩展。顾名思义，应用扩展允许开发者扩展应用的自定义功能和内容，能够让用户在使用其他app时使用该项功能。你可以开发一个应用扩展来执行某些特定的任务，用户使用该扩展后就可以在多个上下文环境中执行该任务。比如说，你提供了一个能让用户把内容分
  • SQLServer实现无限级树结构 macroli oraclesqlSQL Server
    表结构如下： 数据库id path titlesort 排序 1 0 首页 0 2 0,1 新闻 1 3 0,2 JAVA 2 4 0,3 JSP 3 5 0,2,3 业界动态 2 6 0,2,3 国内新闻 1 创建一个存储过程来实现，如果要在页面上使用可以设置一个返回变量将至传过去   create procedure test as begin decla
  • Css居中div，Css居中img，Css居中文本，Css垂直居中div qiaolevip 众观千象学习永无止境每天进步一点点css
    /**********Css居中Div**********/ div.center { width: 100px; margin: 0 auto; } /**********Css居中img**********/ img.center { display: block; margin-left: auto; margin-right: auto; }
  • Oracle 常用操作(实用) 吃猫的鱼 oracle
    SQL>select text from all_source where owner=user and name=upper('&plsql_name');  SQL>select * from user_ind_columns where index_name=upper('&index_name');  将表记录恢复到指定时间段以前
  • iOS中使用RSA对数据进行加密解密 witcheryne iosrsaiPhoneobjective c
      RSA算法是一种非对称加密算法,常被用于加密数据传输.如果配合上数字摘要算法, 也可以用于文件签名. 本文将讨论如何在iOS中使用RSA传输加密数据. 本文环境 mac os  openssl-1.0.1j, openssl需要使用1.x版本, 推荐使用[homebrew](http://brew.sh/)安装. Java 8 RSA基本原理 RS
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他